def METHOD_NAME(
    self, contract: Contract
) -> List[Tuple[FunctionContract, List[Tuple[Node, List[Tuple[Node, FunctionContract]]]]]]:
    """
    Detects if critical contract parameters set by owners and used in arithmetic are missing events
    :param contract: The contract to check
    :return: Functions with nodes of critical operations but no events
    """
    results = []
    for function in contract.functions_entry_points:
        nodes = []
        # Check for any events in the function and skip if found
        # Note: not checking if event corresponds to critical parameter
        if any(ir for node in function.nodes for ir in node.irs if isinstance(ir, EventCall)):
            continue
        # Ignore constructors and private/internal functions
        # Heuristic-1: functions writing to critical parameters are typically "protected".
        # Skip unprotected functions.
        if function.is_constructor or not function.is_protected():
            continue
        # Heuristic-2: Critical operations are where state variables are written and tainted
        # Heuristic-3: Variables of interest are int/uint types that are used (mostly in arithmetic)
        # in other unprotected functions
        # Heuristic-4: Critical operations present but no events in the function is not a good practice
        for node in function.nodes:
            for sv in node.state_variables_written:
                if (
                    is_tainted(sv, function)
                    and isinstance(sv.type, ElementaryType)
                    and sv.type.type in Int + Uint
                ):
                    used_nodes = self._detect_unprotected_use(contract, sv)
                    if used_nodes:
                        nodes.append((node, used_nodes))
        if nodes:
            results.append((function, nodes))
    return results