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

import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import "../../extensions/Purchasable/SlicerPurchasable.sol";
import "../../utils/sliceV1/interfaces/ISliceProductPrice.sol";
import "../interfaces/ITokenERC1155.sol";
import "../../utils/sliceV1/interfaces/IProductsModule.sol";
import {IERC1155} from "@openzeppelin/contracts/interfaces/IERC1155.sol";

struct ClaimableDiscount {
    bool discountClaimable;
    bool discountClaimed;
}

/**
 * @title Hook to mint Compass Coffee NFTs
 * @author jacopo.eth
 */
contract BaseCafe_Compass_SliceHook is SlicerPurchasable, Ownable, ISliceProductPrice {
    /*//////////////////////////////////////////////////////////////
                           IMMUTABLE STORAGE
    //////////////////////////////////////////////////////////////*/

    ITokenERC1155 public constant MINT_NFT_COLLECTION = ITokenERC1155(0x185169058E83CC5Ae9fc1bc758eEA7098a2557CF);
    uint256 public constant MINT_NFT_TOKEN_ID = 0;

    /*//////////////////////////////////////////////////////////////
                                STORAGE
    //////////////////////////////////////////////////////////////*/

    mapping(uint256 slicerId => bool allowed) public allowedSlicerIds;
    mapping(uint256 slicerId => mapping(uint256 productId => ClaimableDiscount)) public productsDiscount;
    mapping(uint256 slicerId => mapping(uint256 productId => uint64 usdcPrice)) public productPrices;

    /*//////////////////////////////////////////////////////////////
                              CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(address productsModuleAddress_, uint256 slicerId_) {
        _productsModuleAddress = productsModuleAddress_;
        _slicerId = slicerId_;

        allowedSlicerIds[425] = true;
        allowedSlicerIds[426] = true;
    }

    /*//////////////////////////////////////////////////////////////
                               FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /**
     * @notice Mint `quantity` NFTs to `account` on purchase
     */
    function onProductPurchase(
        uint256 slicerId,
        uint256 productId,
        address buyer,
        uint256 quantity,
        bytes memory,
        bytes memory
    ) public payable override {
        if (!allowedSlicerIds[slicerId]) revert NotAllowed();

        ClaimableDiscount memory discount = productsDiscount[slicerId][productId];
        if (
            discount.discountClaimable && !discount.discountClaimed
                && IERC1155(address(MINT_NFT_COLLECTION)).balanceOf(buyer, MINT_NFT_TOKEN_ID) != 0
        ) {
            productsDiscount[slicerId][productId].discountClaimed = true;
        }

        MINT_NFT_COLLECTION.mintTo(buyer, MINT_NFT_TOKEN_ID, "", quantity);
    }

    /*//////////////////////////////////////////////////////////////
                               FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /**
     * @notice Called by product owner to set product configs.
     */
    function setPrice(uint256 slicerId, uint256 productId, uint64 price) external onlyOwner {
        productPrices[slicerId][productId] = price;
    }

    /**
     * @notice Called by contract owner to set allowed slicer Ids.
     */
    function setAllowedSlicerId(uint256 slicerId, bool allowed) external onlyOwner {
        allowedSlicerIds[slicerId] = allowed;
    }

    /**
     * @notice Called by contract owner to set product discounts.
     */
    function setProductDiscount(uint256 slicerId, uint256 productId, bool isDiscounted) external onlyOwner {
        productsDiscount[slicerId][productId].discountClaimable = isDiscounted;
    }

    /**
     * @notice Function called by Slice protocol to calculate current product price.
     */
    function productPrice(uint256 slicerId, uint256 productId, address, uint256 quantity, address buyer, bytes memory)
        external
        view
        returns (uint256 ethPrice, uint256 currencyPrice)
    {
        ClaimableDiscount memory discount = productsDiscount[slicerId][productId];

        if (
            discount.discountClaimable && !discount.discountClaimed
                && IERC1155(address(MINT_NFT_COLLECTION)).balanceOf(buyer, MINT_NFT_TOKEN_ID) != 0
        ) {
            quantity--; // 1 product is free
        }

        currencyPrice = productPrices[slicerId][productId] * quantity;
        ethPrice = 0;
    }
}

// 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
pragma solidity ^0.8.0;

struct CurrencyPrice {
    uint248 value;
    bool dynamicPricing;
    address currency;
}

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

struct Function {
    bytes data;
    uint256 value;
    address externalAddress;
    bytes4 checkFunctionSignature;
    bytes4 execFunctionSignature;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1155.sol)

pragma solidity ^0.8.0;

import "../token/ERC1155/IERC1155.sol";

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1155.sol)

pragma solidity ^0.8.0;

import "../token/ERC1155/IERC1155Upgradeable.sol";

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * 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[EIP 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);
}

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165Upgradeable {
    /**
     * @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[EIP 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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.0;

import "../utils/introspection/IERC165Upgradeable.sol";

/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981Upgradeable is IERC165Upgradeable {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(
        uint256 tokenId,
        uint256 salePrice
    ) external view returns (address receiver, uint256 royaltyAmount);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC721Receiver.sol)

pragma solidity ^0.8.0;

import "../token/ERC721/IERC721Receiver.sol";

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

import "./ISlicer.sol";

interface IFundsModule {
    function depositEth(address account, uint256 protocolPayment) external payable;

    function depositTokenFromSlicer(
        uint256 tokenId,
        address account,
        address currency,
        uint256 amount,
        uint256 protocolPayment
    ) external;

    function withdraw(address account, address currency) external;

    function batchWithdraw(address account, address[] memory currencies) external;

    function withdrawOnRelease(
        uint256 tokenId,
        address account,
        address currency,
        uint256 amount,
        uint256 protocolPayment
    ) external payable;

    function batchReleaseSlicers(
        ISlicer[] memory slicers,
        address account,
        address currency,
        bool triggerWithdraw
    ) external;

    function balance(address account, address currency)
        external
        view
        returns (uint256 accountBalance, uint256 protocolPayment);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

interface IOwnable {
    function owner() external view returns (address);

    function transferOwnership(address newOwner) external;

    function renounceOwnership() external;
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

import "../structs/Function.sol";
import "../structs/Price.sol";
import "../structs/ProductParams.sol";
import "../structs/PurchaseParams.sol";
import "./ISliceCore.sol";
import "./IFundsModule.sol";

interface IProductsModule {
    function sliceCore() external view returns (ISliceCore sliceCoreAddress);

    function fundsModule() external view returns (IFundsModule fundsModuleAddress);

    function addProduct(uint256 slicerId, ProductParams memory params, Function memory externalCall_) external;

    function setProductInfo(
        uint256 slicerId,
        uint256 productId,
        uint8 newMaxUnits,
        bool isFree,
        bool isInfinite,
        uint32 newUnits,
        CurrencyPrice[] memory currencyPrices
    ) external;

    function removeProduct(uint256 slicerId, uint256 productId) external;

    function payProducts(PurchaseParams[] calldata purchases) external payable;

    function releaseEthToSlicer(uint256 slicerId) external;

    // function _setCategoryAddress(uint256 categoryIndex, address newCategoryAddress) external;

    function ethBalance(uint256 slicerId) external view returns (uint256);

    function productPrice(
        uint256 slicerId,
        uint256 productId,
        address currency,
        uint256 quantity,
        address buyer,
        bytes memory data
    ) external view returns (Price memory price);

    function validatePurchaseUnits(address account, uint256 slicerId, uint256 productId)
        external
        view
        returns (uint256 purchases);

    function validatePurchase(uint256 slicerId, uint256 productId)
        external
        view
        returns (uint256 purchases, bytes memory purchaseData);

    function availableUnits(uint256 slicerId, uint256 productId)
        external
        view
        returns (uint256 units, bool isInfinite);

    function isProductOwner(uint256 slicerId, uint256 productId, address account)
        external
        view
        returns (bool isAllowed);

    // function categoryAddress(uint256 categoryIndex) external view returns (address);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

import "../structs/Payee.sol";

import "./utils/IOwnable.sol";
import "@openzeppelin/contracts-upgradeable/interfaces/IERC1155Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";

interface ISliceCore is IOwnable, IERC1155Upgradeable, IERC2981Upgradeable {
    function slice(
        Payee[] calldata payees,
        uint256 minimumShares,
        address[] calldata currencies,
        uint256 releaseTimelock,
        uint40 transferableTimelock,
        bool isImmutable,
        bool isControlled
    ) external;

    function reslice(
        uint256 tokenId,
        address payable[] calldata accounts,
        int32[] calldata tokensDiffs
    ) external;

    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) external override;

    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) external override;

    function slicerBatchTransfer(
        address from,
        address[] memory recipients,
        uint256 id,
        uint256[] memory amounts,
        bool release
    ) external;

    function safeTransferFromUnreleased(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) external;

    function setController(uint256 id, address newController) external;

    function setRoyalty(
        uint256 tokenId,
        bool isSlicer,
        bool isActive,
        uint256 royaltyPercentage
    ) external;

    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        override
        returns (address receiver, uint256 royaltyAmount);

    function slicers(uint256 id) external view returns (address);

    function controller(uint256 id) external view returns (address);

    function totalSupply(uint256 id) external view returns (uint256);

    function supply() external view returns (uint256);

    function exists(uint256 id) external view returns (bool);

    function _setBasePath(string calldata basePath_) external;

    function _togglePause() external;
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

interface ISliceProductPrice {
    function productPrice(
        uint256 slicerId,
        uint256 productId,
        address currency,
        uint256 quantity,
        address buyer,
        bytes memory data
    ) external view returns (uint256 ethPrice, uint256 currencyPrice);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/interfaces/IERC1155Receiver.sol";
import "@openzeppelin/contracts/interfaces/IERC721Receiver.sol";

interface ISlicer is IERC721Receiver, IERC1155Receiver {
    function release(
        address account,
        address currency,
        bool withdraw
    ) external;

    function batchReleaseAccounts(
        address[] memory accounts,
        address currency,
        bool withdraw
    ) external;

    function unreleased(address account, address currency)
        external
        view
        returns (uint256 unreleasedAmount);

    function getFee() external view returns (uint256 fee);

    function slicerInfo()
        external
        view
        returns (
            uint256 tokenId,
            uint256 minimumShares,
            address creator,
            bool isImmutable,
            bool isControlled,
            address[] memory currencies
        );

    function isPayeeAllowed(address payee) external view returns (bool);

    function acceptsCurrency(address currency) external view returns (bool);

    function _updatePayees(
        address payable sender,
        address receiver,
        bool toRelease,
        uint256 senderShares,
        uint256 transferredShares
    ) external;

    function _updatePayeesReslice(
        address payable[] memory accounts,
        int32[] memory tokensDiffs,
        uint32 totalSupply
    ) external;

    function _setChildSlicer(uint256 id, bool addChildSlicerMode) external;

    function _setTotalShares(uint256 totalShares) external;

    function _addCurrencies(address[] memory currencies) external;

    function _setCustomFee(bool customFeeActive, uint256 customFee) external;

    function _releaseFromSliceCore(
        address account,
        address currency,
        uint256 accountSlices
    ) external;

    function _releaseFromFundsModule(address account, address currency)
        external
        returns (uint256 amount, uint256 protocolPayment);

    function _handle721Purchase(
        address buyer,
        address contractAddress,
        uint256 tokenId
    ) external;

    function _handle1155Purchase(
        address buyer,
        address contractAddress,
        uint256 quantity,
        uint256 tokenId
    ) external;
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.0;

interface ISlicerPurchasable {
    /**
     * @notice Overridable function containing the requirements for an account to be eligible for the purchase.
     *
     * @param slicerId ID of the slicer calling the function
     * @param productId ID of the product being purchased
     * @param account Address of the account buying the product
     * @param quantity Amount of products being purchased
     * @param slicerCustomData Custom data sent by slicer during product purchase
     * @param buyerCustomData Custom data sent by buyer during product purchase
     *
     * @dev Used on the Slice interface to check whether a user is able to buy a product.
     */
    function isPurchaseAllowed(
        uint256 slicerId,
        uint256 productId,
        address account,
        uint256 quantity,
        bytes memory slicerCustomData,
        bytes memory buyerCustomData
    ) external view returns (bool);

    /**
     * @notice Overridable function to handle external calls on product purchases from slicers.
     *
     * @param slicerId ID of the slicer calling the function
     * @param productId ID of the product being purchased
     * @param account Address of the account buying the product
     * @param quantity Amount of products being purchased
     * @param slicerCustomData Custom data sent by slicer during product purchase
     * @param buyerCustomData Custom data sent by buyer during product purchase
     *
     * @dev Can be inherited by child contracts to add custom logic on product purchases.
     */
    function onProductPurchase(
        uint256 slicerId,
        uint256 productId,
        address account,
        uint256 quantity,
        bytes memory slicerCustomData,
        bytes memory buyerCustomData
    ) external payable;
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

interface ITokenERC1155 {
    /**
     *  @notice Lets an account with MINTER_ROLE mint an NFT.
     *
     *  @param to The address to mint the NFT to.
     *  @param tokenId The tokenId of the NFTs to mint
     *  @param uri The URI to assign to the NFT.
     *  @param amount The number of copies of the NFT to mint.
     *
     */
    function mintTo(address to, uint256 tokenId, string calldata uri, uint256 amount) external;

    function setTokenURI(uint256 tokenId, string calldata uri) external;
}

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

pragma solidity ^0.8.0;

import "../utils/Context.sol";

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

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

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

struct Payee {
    address account;
    uint32 shares;
}

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

struct Price {
    uint256 eth;
    uint256 currency;
    uint256 ethExternalCall;
    uint256 currencyExternalCall;
}

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

import "./SubSlicerProduct.sol";
import "./CurrencyPrice.sol";

struct ProductParams {
    SubSlicerProduct[] subSlicerProducts;
    CurrencyPrice[] currencyPrices;
    bytes data;
    bytes purchaseData;
    uint32 availableUnits;
    // uint32 categoryIndex;
    uint8 maxUnitsPerBuyer;
    bool isFree;
    bool isInfinite;
}

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

struct PurchaseParams {
    uint128 slicerId;
    uint32 quantity;
    address currency;
    uint32 productId;
    bytes buyerCustomData;
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.0;

import "./interfaces/ISlicerPurchasable.sol";

/**
 * @title SlicerPurchasable
 * @author jjranalli
 *
 * @notice Extension enabling basic usage of external calls by slicers upon product purchase.
 */
abstract contract SlicerPurchasable is ISlicerPurchasable {
    /// ============ Errors ============

    /// @notice Thrown if not called from the correct slicer
    error WrongSlicer();
    /// @notice Thrown if not called during product purchase
    error NotPurchase();
    /// @notice Thrown when account is not allowed to buy product
    error NotAllowed();
    /// @notice Thrown when a critical request was not successful
    error NotSuccessful();

    /// ============ Storage ============

    /// ProductsModule contract address
    address internal _productsModuleAddress;
    /// Id of the slicer able to call the functions with the `OnlyOnPurchaseFrom` function
    uint256 internal _slicerId;

    /// ============ Modifiers ============

    /**
     * @notice Checks product purchases are accepted only from correct slicer (modifier)
     */
    modifier onlyOnPurchaseFrom(uint256 slicerId) {
        _onlyOnPurchaseFrom(slicerId);
        _;
    }

    /// ============ Functions ============

    /**
     * @notice Checks product purchases are accepted only from correct slicer (function)
     */
    function _onlyOnPurchaseFrom(uint256 slicerId) internal view virtual {
        if (_slicerId != slicerId) revert WrongSlicer();
        if (msg.sender != _productsModuleAddress) revert NotPurchase();
    }

    /**
     * @notice Overridable function containing the requirements for an account to be eligible for the purchase.
     *
     * @dev Used on the Slice interface to check whether a user is able to buy a product. See {ISlicerPurchasable}.
     */
    function isPurchaseAllowed(uint256, uint256, address, uint256, bytes memory, bytes memory)
        public
        view
        virtual
        override
        returns (bool)
    {
        // Add all requirements related to product purchase here
        // Return true if account is allowed to buy product
        return true;
    }

    /**
     * @notice Overridable function to handle external calls on product purchases from slicers. See {ISlicerPurchasable}
     *
     * @dev Can be inherited by child contracts to add custom logic on product purchases.
     */
    function onProductPurchase(
        uint256 slicerId,
        uint256 productId,
        address buyer,
        uint256 quantity,
        bytes memory slicerCustomData,
        bytes memory buyerCustomData
    ) public payable virtual override onlyOnPurchaseFrom(slicerId) {
        // Check whether the buyer is allowed to purchase the product.
        if (!isPurchaseAllowed(slicerId, productId, buyer, quantity, slicerCustomData, buyerCustomData)) {
            revert NotAllowed();
        }

        // Add product purchase logic here
    }
}

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

struct SubSlicerProduct {
    uint128 subSlicerId;
    uint32 subProductId;
}

{
  "compilationTarget": {
    "src/onchainSummer/BasedMerch/BaseCafe_Compass.sol": "BaseCafe_Compass_SliceHook"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [
    ":@erc721a-upgradeable/=lib/ERC721A-Upgradeable/",
    ":@erc721a/=lib/ERC721A/",
    ":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    ":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    ":@solady/=lib/solady/src/",
    ":@solmate/=lib/solmate/src/",
    ":ERC721A-Upgradeable/=lib/ERC721A-Upgradeable/contracts/",
    ":ERC721A/=lib/ERC721A/contracts/",
    ":dn404/=lib/dn404/src/",
    ":ds-test/=lib/forge-std/lib/ds-test/src/",
    ":erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
    ":forge-std/=lib/forge-std/src/",
    ":murky/=lib/dn404/lib/murky/",
    ":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    ":openzeppelin-contracts/=lib/openzeppelin-contracts/",
    ":openzeppelin/=lib/openzeppelin-contracts-upgradeable/contracts/",
    ":solady/=lib/solady/src/",
    ":solmate/=lib/solmate/src/"
  ],
  "viaIR": true
}