Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE

More Options

• Similar
• Submit Audit
• Compare

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

import {NodeOwners} from "./NodeOwners.sol";

interface ITokenContract {
    function balanceOf(address _owner) external view returns (uint256 balance);
}

contract TokenBalance is NodeOwners {
    struct Expression {
        ITokenContract token;
        Comparator comparator;
        uint256 value;
    }

    enum Comparator {
        EQ,
        LT,
        GT
    }

    mapping(bytes32 => Expression) private expressions;

    event ExpressionSet(bytes32 indexed id, address token, Comparator comparator, uint256 value);

    constructor(address graph, address identity) NodeOwners(graph, identity) {}

    function setExpression(bytes32 id, address _token, Comparator _comparator, uint256 _value) external nodeOwner(id) {
        expressions[id] = Expression(ITokenContract(_token), _comparator, _value);
        emit ExpressionSet(id, _token, _comparator, _value);
    }

    function compare(uint256 valueToCompare, Expression memory expression) internal pure returns (bool) {
        if (expression.comparator == Comparator.EQ) {
            return valueToCompare == expression.value;
        } else if (expression.comparator == Comparator.LT) {
            return valueToCompare < expression.value;
        } else if (expression.comparator == Comparator.GT) {
            return valueToCompare > expression.value;
        } else {
            return false;
        }
    }

    function auth(bytes32 id, address user) external view returns (bool isAuthorised) {
        Expression memory expression = expressions[id];
        uint256 balance = expression.token.balanceOf(user);
        return compare(balance, expression);
    }
}

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

import {IContentGraph} from "../IContentGraph.sol";
import {IIdentityRegistry} from "../interfaces/IIdentityRegistry.sol";

/**
 * @title Node Owners
 * @author Blockchain Creative Labs
 */
contract NodeOwners {
    address contentGraph;
    address identityRegistry;

    error NotAuthorized();

    constructor(address _graph, address _identity) {
        contentGraph = _graph;
        identityRegistry = _identity;
    }

    modifier nodeOwner(bytes32 id) {
        _checkOwner(id);
        _;
    }

    function _checkOwner(bytes32 id) internal view virtual {
        uint256 token = IContentGraph(contentGraph).getNode(id).token;
        address owner = IContentGraph(contentGraph).ownerOf(token);
        address actingAs = IIdentityRegistry(identityRegistry).whoIs(msg.sender);
        if (actingAs != address(0)) {
            require(owner == actingAs, "NodeOwners: Caller is not authorized");
        } else {
            revert NotAuthorized();
        }
    }
}

// SPDX-License-Identifier: CC0-1.0
pragma solidity ^0.8.0;

import "./interfaces/IERC6150.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";

interface IContentGraph is IERC6150, IERC721 {
    event Moved(bytes32 _id, bytes32 indexed _from, bytes32 _to);
    event AccessAuthUpdate(bytes32 _id, address _auth);
    event ReferenceAuthUpdate(bytes32 _id, address _auth);
    event URIUpdate(bytes32 _id, string _uri);

    enum NodeType {
        ORG,
        REFERENCE,
        ASSET
    }

    struct ContentNode {
        bytes32 id;
        NodeType nodeType;
        bytes32 referenceOf;
        string uri;
    }

    struct Node {
        uint256 token;
        NodeType nodeType;
        bytes32 id;
        bytes32 referenceOf;
        string uri;
        address accessAuth;
        address referenceAuth;
    }

    /**
     * @notice Publishes a new set content node (assets/references) to the passed parent id.
     * @param parentId The id of an ORG node to publish the set of content nodes.
     * @param content A list of content.
     */
    function publishBulk(bytes32 parentId, ContentNode[] calldata content) external;

    /**
     * @notice Publishes a new asset node at a given parent in addition to setting the uri for the asset node.
     * @param parentId The id of an ORG node to publish the set of content nodes.
     * @param content A content node to publish.
     */
    function publish(bytes32 parentId, ContentNode calldata content) external;

    /**
     * @notice Creates a node of a given type under the parent node provided.
     * @param id The id of the node to create, must follow correct form based on type.
     * @param parentId The id of a admin node to publish the node under
     * @param nodeType The type of node to create, ADMIN, COLLECTION, or ASSET
     */
    function createNode(bytes32 id, bytes32 parentId, NodeType nodeType) external;

    /**
     * @notice Creates a node of a given type under the parent node provided.
     * @param id The id of the node to create, must follow the correct form based on type.
     * @param parentId The id of a ORG node to publish the node under
     * @param nodeType The type of node to create, ORG, REFERENCE, or ASSET
     * @param referenceOf If the type is of REFERENCE the id of the node that is being referenced
     */
    function createNode(bytes32 id, bytes32 parentId, NodeType nodeType, bytes32 referenceOf) external;

    /**
     * @notice Moves a node from current parent to a new parent.
     * @param id The id of the node to move.
     * @param newParentId The id of an existing admin node to move the node under.
     */
    function move(bytes32 id, bytes32 newParentId) external;

    /**
     * @notice Sets the access auth module for a given node.
     * @param id The id of the node whose auth modules should be set
     * @param accessAuth The address to the auth module to be used access of node's content.
     */
    function setAccessAuth(bytes32 id, address accessAuth) external;

    /**
     * @notice Sets the reference auth module for a given node.
     * @param id The id of the node whose auth modules should be set
     * @param referenceAuth The address to the auth module to be used for referencing a node in collection.
     */
    function setReferenceAuth(bytes32 id, address referenceAuth) external;

    /**
     * @notice Sets the uri for a node.
     * @param id The id of the node.
     * @param uri The URI to the metadata to set for a node.
     */
    function setURI(bytes32 id, string calldata uri) external;

    /**
     * @notice Validates if a given user may access the content at a given node.
     * @param id The id of the node whose content is being accessed.
     * @param user The address of the user who wishes to access the content.
     */
    function auth(bytes32 id, address user) external view returns (bool);

    /**
     * @notice Validates if a given user may reference a given node in a collection.
     * @param id The id of the node who is being referenced.
     * @param user The address of the user who wishes to reference the node.
     */
    function refAuth(bytes32 id, address user) external view returns (bool);

    /**
     * @notice retrieve node from node id
     * @param id The id of the node to retrieve.
     */
    function getNode(bytes32 id) external view returns (Node memory node);

    /**
     * @dev retrieve node from token id
     * @param token The tokenId for the node to retrieve.
     */
    function tokenToNode(uint256 token) external view returns (Node memory node);
}

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

interface IIdentityRegistry {
    function registerRoot(address root, string memory name) external;
    function deregisterRoot(address root) external;
    function registerIdentity(
        bytes memory signature,
        address root,
        address identity,
        uint256 expirary,
        uint256 deadline
    ) external;
    function deregisterIdentity(bytes memory signature, address root, address identity, uint256 deadline) external;
    function whoIs(address identity) external view returns (address root);
    function getSignature(address _root, address _identity)
        external
        view
        returns (bytes memory signature, bytes32 digest, address root, address identity, uint256 expirary);
}

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

import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";

// Note: the ERC-165 identifier for this interface is 0x897e2c73.
interface IERC6150 { /* is IERC721, IERC165 */
    /**
     * @notice Emitted when `tokenId` token under `parentId` is minted.
     * @param minter The address of minter
     * @param to The address received token
     * @param parentId The id of parent token, if it's zero, it means minted `tokenId` is a root token.
     * @param tokenId The id of minted token, required to be greater than zero
     */
    event Minted(address indexed minter, address indexed to, uint256 parentId, uint256 tokenId);

    /**
     * @notice Get the parent token of `tokenId` token.
     * @param tokenId The child token
     * @return parentId The Parent token found
     */
    function parentOf(uint256 tokenId) external view returns (uint256 parentId);

    /**
     * @notice Get the children tokens of `tokenId` token.
     * @param tokenId The parent token
     * @return childrenIds The array of children tokens
     */
    function childrenOf(uint256 tokenId) external view returns (uint256[] memory childrenIds);

    /**
     * @notice Check the `tokenId` token if it is a root token.
     * @param tokenId The token want to be checked
     * @return Return `true` if it is a root token; if not, return `false`
     */
    function isRoot(uint256 tokenId) external view returns (bool);

    /**
     * @notice Check the `tokenId` token if it is a leaf token.
     * @param tokenId The token want to be checked
     * @return Return `true` if it is a leaf token; if not, return `false`
     */
    function isLeaf(uint256 tokenId) external view returns (bool);
}

// Note: the ERC-165 identifier for this interface is 0xba541a2e.
interface IERC6150Enumerable is IERC6150 /* IERC721Enumerable */ {
    /**
     * @notice Get total amount of children tokens under `parentId` token.
     * @dev If `parentId` is zero, it means get total amount of root tokens.
     * @return The total amount of children tokens under `parentId` token.
     */
    function childrenCountOf(uint256 parentId) external view returns (uint256);

    /**
     * @notice Get the token at the specified index of all children tokens under `parentId` token.
     * @dev If `parentId` is zero, it means get root token.
     * @return The token ID at `index` of all chlidren tokens under `parentId` token.
     */
    function childOfParentByIndex(uint256 parentId, uint256 index) external view returns (uint256);

    /**
     * @notice Get the index position of specified token in the children enumeration under specified parent token.
     * @dev Throws if the `tokenId` is not found in the children enumeration.
     * If `parentId` is zero, means get root token index.
     * @param parentId The parent token
     * @param tokenId The specified token to be found
     * @return The index position of `tokenId` found in the children enumeration
     */
    function indexInChildrenEnumeration(uint256 parentId, uint256 tokenId) external view returns (uint256);
}

// Note: the ERC-165 identifier for this interface is 0x4ac0aa46.
interface IERC6150Burnable is IERC6150 {
    /**
     * @notice Burn the `tokenId` token.
     * @dev Throws if `tokenId` is not a leaf token.
     * Throws if `tokenId` is not a valid NFT.
     * Throws if `owner` is not the owner of `tokenId` token.
     * Throws unless `msg.sender` is the current owner, an authorized operator, or the approved address for this token.
     * @param tokenId The token to be burnt
     */
    function safeBurn(uint256 tokenId) external;

    /**
     * @notice Batch burn tokens.
     * @dev Throws if one of `tokenIds` is not a leaf token.
     * Throws if one of `tokenIds` is not a valid NFT.
     * Throws if `owner` is not the owner of all `tokenIds` tokens.
     * Throws unless `msg.sender` is the current owner, an authorized operator, or the approved address for all `tokenIds`.
     * @param tokenIds The tokens to be burnt
     */
    function safeBatchBurn(uint256[] memory tokenIds) external;
}

// Note: the ERC-165 identifier for this interface is 0xfa574808.
interface IERC6150ParentTransferable is IERC6150 {
    /**
     * @notice Emitted when the parent of `tokenId` token changed.
     * @param tokenId The token changed
     * @param oldParentId Previous parent token
     * @param newParentId New parent token
     */
    event ParentTransferred(uint256 tokenId, uint256 oldParentId, uint256 newParentId);

    /**
     * @notice Transfer parentship of `tokenId` token to a new parent token
     * @param newParentId New parent token id
     * @param tokenId The token to be changed
     */
    function transferParent(uint256 newParentId, uint256 tokenId) external;

    /**
     * @notice Batch transfer parentship of `tokenIds` to a new parent token
     * @param newParentId New parent token id
     * @param tokenIds Array of token ids to be changed
     */
    function batchTransferParent(uint256 newParentId, uint256[] memory tokenIds) external;
}

// Note: the ERC-165 identifier for this interface is 0x1d04f0b3.
interface IERC6150AccessControl is IERC6150 {
    /**
     * @notice Check the account whether a admin of `tokenId` token.
     * @dev Each token can be set more than one admin. Admin have permission to do something to the token, like mint child token,
     * or burn token, or transfer parentship.
     * @param tokenId The specified token
     * @param account The account to be checked
     * @return If the account has admin permission, return true; otherwise, return false.
     */
    function isAdminOf(uint256 tokenId, address account) external view returns (bool);

    /**
     * @notice Check whether the specified parent token and account can mint children tokens
     * @dev If the `parentId` is zero, check whether account can mint root nodes
     * @param parentId The specified parent token to be checked
     * @param account The specified account to be checked
     * @return If the token and account has mint permission, return true; otherwise, return false.
     */
    function canMintChildren(uint256 parentId, address account) external view returns (bool);

    /**
     * @notice Check whether the specified token can be burnt by specified account
     * @param tokenId The specified token to be checked
     * @param account The specified account to be checked
     * @return If the tokenId can be burnt by account, return true; otherwise, return false.
     */
    function canBurnTokenByAccount(uint256 tokenId, address account) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC-721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC-721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or
     *   {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

{
  "remappings": [
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-foundry-upgrades/=lib/openzeppelin-foundry-upgrades/src/",
    "solidity-stringutils/=lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/",
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "halmos-cheatcodes/=lib/openzeppelin-contracts-upgradeable/lib/halmos-cheatcodes/src/",
    "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "none",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "cancun",
  "viaIR": false,
  "libraries": {}
}

[{"inputs":[{"internalType":"address","name":"graph","type":"address"},{"internalType":"address","name":"identity","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"NotAuthorized","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"id","type":"bytes32"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"enum TokenBalance.Comparator","name":"comparator","type":"uint8"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"ExpressionSet","type":"event"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"},{"internalType":"address","name":"user","type":"address"}],"name":"auth","outputs":[{"internalType":"bool","name":"isAuthorised","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"id","type":"bytes32"},{"internalType":"address","name":"_token","type":"address"},{"internalType":"enum TokenBalance.Comparator","name":"_comparator","type":"uint8"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"setExpression","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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