Share & Discover Smart Contract Code

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

import {ILSP1UniversalReceiver} from "@lukso/lsp1-contracts/contracts/ILSP1UniversalReceiver.sol";
import {ILSP7DigitalAsset} from "@lukso/lsp7-contracts/contracts/ILSP7DigitalAsset.sol";

/// @dev LSP26 follow notification typeId
bytes32 constant _TYPEID_LSP26_FOLLOW =
    0x71e02f9f05bcd5816ec4f3134aa2e5a916669537000000000000000000000000;

/// @dev LSP26 Follower Registry on LUKSO Mainnet
address constant LSP26_FOLLOWER_REGISTRY = 0xf01103E5a9909Fc0DBe8166dA7085e0285daDDcA;

/**
 * @title TipOnFollowDelegate
 * @notice Auto-tip LSP7 tokens to every new follower via LSP1.
 *
 * SETUP on your Universal Profile:
 * 1. Set LSP1UniversalReceiverDelegate:<followTypeId> = address(this)
 * 2. Authorize this contract as LSP7 operator for your tip budget
 */
contract TipOnFollowDelegate is ILSP1UniversalReceiver {
    ILSP7DigitalAsset public immutable tipToken;
    uint256 public immutable tipAmount;

    event TipSent(address indexed universalProfile, address indexed follower, uint256 amount);
    event TipFailed(address indexed universalProfile, address indexed follower, string reason);

    constructor(address _tipToken, uint256 _tipAmount) {
        tipToken = ILSP7DigitalAsset(_tipToken);
        tipAmount = _tipAmount;
    }

    function universalReceiver(
        bytes32 typeId,
        bytes calldata data
    ) external override returns (bytes memory) {
        if (typeId != _TYPEID_LSP26_FOLLOW) return "";
        if (msg.sender != LSP26_FOLLOWER_REGISTRY) return "";
        if (data.length < 20) return "";

        address follower = address(bytes20(data[data.length - 20:]));
        address universalProfile = tx.origin;

        try tipToken.transfer(universalProfile, follower, tipAmount, true, "") {
            emit TipSent(universalProfile, follower, tipAmount);
        } catch Error(string memory reason) {
            emit TipFailed(universalProfile, follower, reason);
        } catch {
            emit TipFailed(universalProfile, follower, "unknown error");
        }

        return "";
    }
}

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

import {LSP7DigitalAsset} from "@lukso/lsp7-contracts/contracts/LSP7DigitalAsset.sol";

/**
 * @title TaxedLSP7Token
 * @notice LSP7 token with a configurable transfer tax routed to treasury.
 *
 * Tax rate in basis points: 100 = 1%, 250 = 2.5% (max: 1000 = 10%)
 * Treasury can be any Universal Profile address.
 */
contract TaxedLSP7Token is LSP7DigitalAsset {
    address public treasury;
    uint256 public taxBasisPoints;

    event TaxCollected(address indexed from, address indexed to, uint256 taxAmount);

    constructor(
        string memory name_,
        string memory symbol_,
        address newOwner_,
        address treasury_,
        uint256 taxBasisPoints_,
        uint256 initialSupply_
    ) LSP7DigitalAsset(name_, symbol_, newOwner_, 0, false) {
        require(taxBasisPoints_ <= 1000, "TaxedLSP7: max 10%");
        treasury = treasury_;
        taxBasisPoints = taxBasisPoints_;
        if (initialSupply_ > 0) _mint(newOwner_, initialSupply_, true, "");
    }

    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256 amount,
        bool force,
        bytes memory data
    ) internal override {
        super._beforeTokenTransfer(operator, from, to, amount, force, data);

        // Skip tax on mint, burn, or treasury-involved transfers
        if (from == address(0) || to == address(0)) return;
        if (from == treasury || to == treasury) return;

        uint256 taxAmount = (amount * taxBasisPoints) / 10_000;
        if (taxAmount == 0) return;

        _transfer(from, treasury, taxAmount, true, "");
        emit TaxCollected(from, to, taxAmount);
    }

    function setTreasury(address newTreasury) external onlyOwner {
        treasury = newTreasury;
    }

    function setTaxRate(uint256 newBasisPoints) external onlyOwner {
        require(newBasisPoints <= 1000, "TaxedLSP7: max 10%");
        taxBasisPoints = newBasisPoints;
    }
}

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

import {IERC725Y} from "@erc725/smart-contracts/contracts/interfaces/IERC725Y.sol";

/**
 * @title LSP6BatchPermissionChecker
 * @notice Validate LSP6 permissions for multiple controllers in one getDataBatch call.
 *
 * USE CASE: Pre-flight check before privileged dApp actions.
 * Instead of failing mid-transaction, verify permissions upfront.
 */
contract LSP6BatchPermissionChecker {
    bytes10 constant _PERMISSIONS_KEY_PREFIX = 0x4b80742de2bf82acb3630000;

    /// @notice Check if a controller has ALL required permissions on a UP.
    function checkPermissions(
        address universalProfile,
        address controller,
        bytes32 requiredPermissions
    ) external view returns (bool hasAll, bytes32 missing) {
        bytes32 key = _buildPermissionsKey(controller);
        bytes memory raw = IERC725Y(universalProfile).getData(key);
        if (raw.length == 0) return (false, requiredPermissions);

        bytes32 granted = abi.decode(raw, (bytes32));
        missing = requiredPermissions ^ (granted & requiredPermissions);
        hasAll = (missing == bytes32(0));
    }

    /// @notice Batch check permissions for multiple controllers at once.
    function batchCheckPermissions(
        address universalProfile,
        address[] calldata controllers,
        bytes32 requiredPerms
    ) external view returns (bool[] memory results) {
        uint256 count = controllers.length;
        results = new bool[](count);

        bytes32[] memory keys = new bytes32[](count);
        for (uint256 i = 0; i < count; i++) {
            keys[i] = _buildPermissionsKey(controllers[i]);
        }

        bytes[] memory rawValues = IERC725Y(universalProfile).getDataBatch(keys);
        for (uint256 i = 0; i < count; i++) {
            if (rawValues[i].length == 0) continue;
            bytes32 granted = abi.decode(rawValues[i], (bytes32));
            results[i] = (granted & requiredPerms) == requiredPerms;
        }
    }

    function _buildPermissionsKey(address controller) internal pure returns (bytes32) {
        return bytes32(abi.encodePacked(_PERMISSIONS_KEY_PREFIX, controller));
    }
}