certora-cli-alpha-master 20250508.17.30.185947__tar.gz → 20250519.9.10.855346__tar.gz

{certora_cli_alpha_master-20250508.17.30.185947/certora_cli_alpha_master.egg-info → certora_cli_alpha_master-20250519.9.10.855346}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: certora-cli-alpha-master
-Version: 20250508.17.30.185947
+Version: 20250519.9.10.855346
 Summary: Runner for the Certora Prover
 Home-page: https://pypi.org/project/certora-cli-alpha-master
 Author: Certora
@@ -37,4 +37,4 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-Commit 5d897cd.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.
+Commit 081395d.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

certora_cli_alpha_master-20250519.9.10.855346/README.md

@@ -0,0 +1 @@
+Commit 081395d.                    Build and Run scripts for executing the Certora Prover on Solidity smart contracts.

{certora_cli_alpha_master-20250508.17.30.185947 → certora_cli_alpha_master-20250519.9.10.855346}/certora_cli/CertoraProver/certoraBuild.py

@@ -25,8 +25,11 @@ from collections import OrderedDict, defaultdict
 from enum import Enum
 from functools import lru_cache
 from pathlib import Path
-from typing import Any, Dict, List, Tuple, Optional, Set, Iterator, NoReturn
 from Crypto.Hash import keccak
+import tempfile
+
+from typing import Any, Dict, List, Tuple, Optional, Set, Iterator, NoReturn
+
 
 from CertoraProver.certoraBuildCacheManager import CertoraBuildCacheManager, CachedFiles
 from CertoraProver.certoraBuildDataClasses import CONTRACTS, ImmutableReference, ContractExtension, ContractInSDC, SDC, \
@@ -35,6 +38,7 @@ from CertoraProver.certoraCompilerParameters import SolcParameters
 from CertoraProver.certoraSourceFinders import add_source_finders
 from CertoraProver.certoraVerifyGenerator import CertoraVerifyGenerator
 from CertoraProver.certoraContractFuncs import Func, InternalFunc, STATEMUT, SourceBytes
+
 from Shared.certoraUtils import is_relative_to
 
 scripts_dir_path = Path(__file__).parent.parent.resolve()  # containing directory
@@ -54,7 +58,11 @@ from Shared import certoraValidateFuncs as Vf
 from CertoraProver import certoraContextValidator as Cv
 from Shared import certoraUtils as Util
 import CertoraProver.certoraContext as Ctx
-
+from CertoraProver import storageExtension
+from CertoraProver.storageExtension import (
+    NameSpacedStorage,
+    NewStorageInfo,
+)
 
 BUILD_IS_LIBRARY = False
 AUTO_FINDER_PREFIX = "autoFinder_"
@@ -72,6 +80,7 @@ MUTANTS_LOCATION = "mutants_location"
 
 FunctionSig = Tuple[str, List[str], List[str], str]
 
+
 # logger for building the abstract syntax tree
 ast_logger = logging.getLogger("ast")
 # logger for issues calling/shelling out to external functions
@@ -84,12 +93,10 @@ build_logger = logging.getLogger("build_conf")
 # logger of the build cache
 build_cache_logger = logging.getLogger("build_cache")
 
-
 def fatal_error(logger: logging.Logger, msg: str) -> NoReturn:
     logger.fatal(msg)
     raise Exception(msg)
 
-
 class InputConfig:
     def __init__(self, context: CertoraContext) -> None:
         """
@@ -1396,7 +1403,7 @@ class CertoraBuildGenerator:
             if not self.context.strict_solc_optimizer and self.context.solc_via_ir:
                 # The default optimizer steps (taken from libsolidity/interface/OptimiserSettings.h) but with the
                 # full inliner step removed
-                solc0_8_26_to_0_8_29 = ("dhfoDgvulfnTUtnIfxa[r]EscLMVcul[j]Trpeulxa[r]cLCTUca[r]LSsTFOtfDnca[r]" +
+                solc0_8_26_to_0_8_30 = ("dhfoDgvulfnTUtnIfxa[r]EscLMVcul[j]Trpeulxa[r]cLCTUca[r]LSsTFOtfDnca[r]" +
                                         "IulcscCTUtx[scCTUt]TOntnfDIuljmul[jul]VcTOculjmul")
                 solc0_8_13_to_0_8_25 = "dhfoDgvulfnTUtnIf[xa[r]EscLMcCTUtTOntnfDIulLculVcul[j]T" + \
                                        "peulxa[rul]xa[r]cLgvifCTUca[r]LSsTFOtfDnca[r]Iulc]jmul[jul]VcTOculjmul"
@@ -1440,8 +1447,8 @@ class CertoraBuildGenerator:
                     yul_optimizer_steps = solc0_8_12
                 elif minor == 8 and 13 <= patch <= 25:
                     yul_optimizer_steps = solc0_8_13_to_0_8_25
-                elif minor == 8 and 26 <= patch <= 29:
-                    yul_optimizer_steps = solc0_8_26_to_0_8_29
+                elif minor == 8 and 26 <= patch <= 30:
+                    yul_optimizer_steps = solc0_8_26_to_0_8_30
                 assert yul_optimizer_steps is not None, \
                     'Yul Optimizer steps missing for requested Solidity version. Please contact Certora team.'
 
@@ -2539,7 +2546,6 @@ class CertoraBuildGenerator:
             Util.print_progress_message(f"Compiling {orig_file_name}...")
             sdc_pre_finders = self.collect_for_file(build_arg_contract_file, i, compiler_lang, Path(os.getcwd()),
                                                     path_for_compiler_collector_file, original_sdc=None)
-
             # Build sources tree
             build_logger.debug("Building source tree")
             sources_from_pre_finder_SDCs = set()
@@ -2672,8 +2678,154 @@ class CertoraBuildGenerator:
         self.handle_links()
         self.handle_struct_links()
         self.handle_contract_extensions()
+        if self.context.storage_extension_annotation:
+            self.handle_erc7201_annotations()
         self.handle_storage_extension_harnesses()
 
+    def extract_slayout(self, original_file: str, ns_storage: Set[NameSpacedStorage]) -> NewStorageInfo:
+        """
+        Given a file containing a contract with namespaced storage, extract the storage information
+        corresponding to the namespaced types.
+
+        Args:
+            original_file: Path to the Solidity file containing namespaced storage declarations
+            ns_storage: Set of tuples (type_name, namespace) for each namespaced storage
+
+        Returns:
+            NewStorageInfo: A tuple (fields, types) where:
+                - fields: List of new fields added by the namespaced storage
+                - types: Dictionary of types referenced by the fields
+        """
+        file_dir = Path(original_file).parent
+
+        # Generate a unique name for the harness contract based on the contract names in the file
+        harness_name = storageExtension.generate_harness_name(original_file)
+
+        with tempfile.NamedTemporaryFile(mode="w+t", suffix=".sol", dir=file_dir, delete=True) as tmp_file:
+            # Import the original file.
+            # Note we import and don't inline the file's contents since that's how the
+            # original file is accessed also in the actual code, and compiling it
+            # directly can cause issues.
+            tmp_file.write(f"import \"{original_file}\";\n\n")
+
+            # Write the harness contract with dummy fields for each namespaced storage
+            var_to_slot = storageExtension.write_harness_contract(tmp_file, harness_name, ns_storage)
+            tmp_file.flush()
+
+            if self.context.extract_storage_extension_annotation:
+                # If the flag is set, save the storage extension contract
+                build_dir = Util.get_build_dir()
+                shutil.copyfile(
+                    Path(tmp_file.name),
+                    build_dir / f"{Path(original_file).stem}_storage_extension.sol"
+                )
+
+            # Add harness to compiler map
+            storageExtension.add_harness_to_compiler_map(
+                original_file,
+                tmp_file,
+                self.context
+            )
+
+            # normalize the path exactly the way collect_for_file expects it:
+            abs_path = Util.abs_posix_path(tmp_file.name)
+            self.context.file_to_contract[abs_path] = {harness_name}
+
+            try:
+                # Compile & fetch the raw storage_layout
+                compile_idx = storageExtension.get_next_file_index(self.file_to_sdc_name)
+                sdcs = self.collect_for_file(tmp_file.name, compile_idx, CompilerLangSol(), Path.cwd(), Util.abs_posix_path(tmp_file.name), None)
+                if not sdcs:
+                    raise RuntimeError(f"Failed to compile harness contract for {tmp_file}")
+                layout = storageExtension.extract_harness_contract_layout(sdcs, harness_name)
+
+                # Remap each slot according to the ERC-7201 namespace
+                remapped_fields = storageExtension.remapped_fields_from_layout(layout, var_to_slot)
+
+                return (remapped_fields, layout.get('types', {}))
+
+            except Exception as e:
+                build_logger.error(f"Error extracting storage layout for {original_file}: {str(e)}")
+                raise
+            finally:
+                # Delete the key from the context
+                self.context.file_to_contract.pop(abs_path, None)
+
+    def handle_erc7201_annotations(self) -> None:
+        """
+        Look for contracts that use erc-7201 namespaced storage layout
+        (see https://eips.ethereum.org/EIPS/eip-7201).
+
+        Find contracts A s.t. A contain a type declaration with such an annotation, e.g.
+          /** @custom:storage-location erc-7201:some.name.space */
+          struct T { ... }
+
+        Then, for any contract C that has A as a base contract, _extend_ C's storage layout
+        information such that it contains the information for a `T` at the slot
+        erc-7201(some.name.space) as defined in the EIP.
+        """
+        # Find all erc7201-like contracts, generate+compile a harness & extract layout information
+        # maps (path,contract) -> new storage info added by (path,contract)
+        slayouts: Dict[Tuple[str, str], NewStorageInfo] = {}
+
+        # Scan all of the contracts (including dependencies of targets) for namespaced storage
+        # layout information
+        for target_file in self.context.file_paths:
+            if target_file not in self.asts:
+                # No AST for this file, so we can't do anything
+                continue
+            for (imported_file, imported_file_ast) in self.asts[target_file].items():
+                for def_node in imported_file_ast.values():
+                    if def_node.get("nodeType") != "ContractDefinition":
+                        continue
+
+                    # Construct a key for the contract definition node
+                    contract_name = def_node.get("name")
+                    key = (imported_file, contract_name)
+                    if key in slayouts:
+                        # We already have this contract's storage layout information
+                        continue
+
+                    # Collect any @custom:storage-location annotations
+                    ns_storage = storageExtension.get_namespace_storage_from_ast(def_node)
+
+                    if not ns_storage:
+                        # No namespaced storage found in this contract
+                        continue
+
+                    # Now that we have all the storage layout information, extract it once
+                    slayouts[key] = self.extract_slayout(imported_file, ns_storage)
+
+        if self.context.test == str(Util.TestValue.STORAGE_EXTENSION_LAYOUT):
+            raise Util.TestResultsReady(slayouts)
+
+        if not slayouts:
+            # No contracts with namespaced storage found
+            return
+
+        # Finally, extend each target contract with the storage layout info from
+        # all of its base contracts
+        for target in self.get_primary_contracts_from_sdcs():
+            if target.name not in self.context.contract_to_file:
+                # This is a contract that was not compiled, so we don't have a file for it
+                continue
+            target_file = self.context.contract_to_file[target.name]
+            base_contracts = self.retrieve_base_contracts_list(
+                target_file,
+                Util.abs_posix_path(target_file),
+                target.name
+            )
+            extensions: Set[str] = set()
+            harnesses: Dict[str, NewStorageInfo] = {}
+            for base in base_contracts:
+                layout = slayouts.get((base[0], base[1]))
+                if layout is not None:
+                    extensions.add(base[1])
+                    harnesses[base[1]] = layout
+                else:
+                    build_logger.warning(f"Could not find storage layout for {base[1]} in {base[0]}")
+            storageExtension.apply_extensions(target, extensions, harnesses)
+
     def handle_storage_extension_harnesses(self) -> None:
         def new_field_of_node(ext_instance: Any, node: Dict[str, Any]) -> Optional[Dict[str, Any]]:
             """
@@ -2760,52 +2912,6 @@ class CertoraBuildGenerator:
                     new_fields.append(new_field)
 
             return (ext_instance, extension_sdc_name, new_fields)
-
-        def apply_extensions(target_contract: Any, extensions: Set[str], to_add: Dict[str, Tuple[List[Dict[str, Any]], Dict[str, Any]]]) -> None:
-            """
-            Apply the fields from each extension to the target contract,
-            """
-            if target_contract.storage_layout.get("storage") is None:
-                target_contract.storage_layout["storage"] = []
-            if target_contract.storage_layout.get("types") is None:
-                target_contract.storage_layout["types"] = {}
-            target_slots = {storage["slot"] for storage in target_contract.storage_layout["storage"]}
-            target_vars = {storage["label"] for storage in target_contract.storage_layout["storage"]}
-            # Keep track of slots we've added, and error if we
-            # find two extensions extending the same slot
-            added_slots: Dict[str, str] = {}
-            added_vars: Dict[str, str] = {}
-            for ext in extensions:
-                (new_fields, new_types) = to_add[ext]
-
-                for f in new_fields:
-                    # See if any of the new fields is a slot or variable name we've already added
-                    slot = f["slot"]
-                    var = f["label"]
-                    if slot in added_slots:
-                        seen = added_slots[slot]
-                        raise Util.CertoraUserInputError(f"Slot {slot} added to {target_contract.name} by {ext} was already added by {seen}")
-
-                    if var in added_vars:
-                        seen = added_vars[var]
-                        raise Util.CertoraUserInputError(f"Var '{var}' added to {target_contract.name} by {ext} was already added by {seen}")
-
-                    if slot in target_slots:
-                        raise Util.CertoraUserInputError(f"Slot {slot} added to {target_contract.name} by {ext} is already mapped by {target_contract.name}")
-
-                    if var in target_vars:
-                        raise Util.CertoraUserInputError(f"Var '{var}' added to {target_contract.name} by {ext} is already declared by {target_contract.name}")
-
-                    added_slots[slot] = ext
-                    added_vars[var] = ext
-
-                target_contract.storage_layout["storage"].extend(new_fields)
-
-                for (new_id, new_ty) in new_types.items():
-                    if new_id in target_contract.storage_layout["types"]:
-                        continue
-                    target_contract.storage_layout["types"][new_id] = new_ty
-
         extension_contracts: Set[str] = set()
         storage_extensions: Dict[str, Set[str]] = defaultdict(set)
         storage_ext = self.context.storage_extension_harnesses
@@ -2834,7 +2940,7 @@ class CertoraBuildGenerator:
             sdc = self.SDCs[target_sdc]
             target_contract = sdc.find_contract(target)
             assert target_contract is not None, f"could not find contract for {target}"
-            apply_extensions(target_contract, extensions, extension_to_fields_and_types)
+            storageExtension.apply_extensions(target_contract, extensions, extension_to_fields_and_types)
 
     def finders_compilation_round(self,
                                   build_arg_contract_file: str,

{certora_cli_alpha_master-20250508.17.30.185947 → certora_cli_alpha_master-20250519.9.10.855346}/certora_cli/CertoraProver/certoraBuildRust.py

@@ -16,7 +16,7 @@
 import glob
 import shutil
 from pathlib import Path
-from typing import Set, List
+from typing import Set
 
 from CertoraProver.certoraBuild import build_source_tree
 from CertoraProver.certoraContextClass import CertoraContext
@@ -25,42 +25,9 @@ import CertoraProver.certoraContextAttributes as Attrs
 from Shared import certoraUtils as Util
 
 
-def build_rust_app(context: CertoraContext) -> None:
-    build_command: List[str] = []
-    feature_flag = None
-    if context.build_script:
-        build_command = [context.build_script]
-        feature_flag = '--cargo_features'
-
-    elif not context.files:
-        build_command = ["cargo", "certora-sbf"]
-        feature_flag = '--features'
-        if context.cargo_tools_version:
-            build_command.append("--tools-version")
-            build_command.append(context.cargo_tools_version)
-
-    if build_command:
-        if context.cargo_features is not None:
-            build_command.extend([feature_flag] + context.cargo_features)
-
-        build_command.extend(['--json', '-l'])
-
-        if context.test == str(Util.TestValue.SOLANA_BUILD_CMD):
-            raise Util.TestResultsReady(build_command)
-
-        run_rust_build(context, build_command)
-
-    else:
-        if not context.files:
-            raise Util.CertoraUserInputError("'files' or 'build_script' must be set for Rust projects")
-        if len(context.files) > 1:
-            raise Util.CertoraUserInputError("Rust projects must specify exactly one executable in 'files'.")
-
-        try:
-            Util.get_certora_sources_dir().mkdir(parents=True, exist_ok=True)
-            shutil.copy(Util.get_last_conf_file(), Util.get_certora_sources_dir() / Util.LAST_CONF_FILE)
-        except Exception as e:
-            raise Util.CertoraUserInputError(f"Collecting build files failed with the exception: {e}")
+def set_rust_build_directory(context: CertoraContext) -> None:
+    if not context.files:
+        build_rust_app(context)
 
     copy_files_to_build_dir(context)
 
@@ -74,6 +41,25 @@ def build_rust_app(context: CertoraContext) -> None:
     except Exception as e:
         raise Util.CertoraUserInputError(f"Collecting build files failed with the exception: {e}")
 
+def build_rust_app(context: CertoraContext) -> None:
+    assert not context.files, "build_rust_app: expecting files to be empty"
+    if context.build_script:
+        build_command = [context.build_script, '--json', '-l']
+        feature_flag = '--cargo_features'
+    else:  # cargo
+        build_command = ["cargo", "certora-sbf", '--json']
+        feature_flag = '--features'
+        if context.cargo_tools_version:
+            build_command.extend(["--tools-version", context.cargo_tools_version])
+
+    if context.cargo_features is not None:
+        build_command.append(feature_flag)
+        build_command.extend(context.cargo_features)
+
+    if context.test == str(Util.TestValue.SOLANA_BUILD_CMD):
+        raise Util.TestResultsReady(build_command)
+
+    run_rust_build(context, build_command)
 
 def add_solana_files_from_prover_args(context: CertoraContext) -> None:
     if context.prover_args:
@@ -134,7 +120,7 @@ def collect_files_from_rust_sources(context: CertoraContext, sources: Set[Path])
                     sources.add(file_path)
 
         sources.add(project_directory.absolute())
-        if Path(context.build_script).exists():
+        if context.build_script:
             sources.add(Path(context.build_script).resolve())
     if getattr(context, 'conf_file', None) and Path(context.conf_file).exists():
         sources.add(Path(context.conf_file).absolute())

{certora_cli_alpha_master-20250508.17.30.185947 → certora_cli_alpha_master-20250519.9.10.855346}/certora_cli/CertoraProver/certoraCloudIO.py

@@ -70,6 +70,16 @@ Response = requests.models.Response
 
 FEATURES_REPORT_FILE = Path("featuresReport.json")
 
+class EcoEnum(Util.NoValEnum):
+    EVM = Util.auto()
+    SOROBAN = Util.auto()
+    SOLANA = Util.auto()
+
+class ProductEnum(Util.NoValEnum):
+    PROVER = Util.auto()
+    RANGER = Util.auto()
+    SOPHY = Util.auto()
+
 
 class TimeError(Exception):
     """A custom exception used to report on time elapsed errors"""
@@ -631,6 +641,20 @@ class CloudVerification:
 
         auth_data["useLatestFe"] = self.context.fe_version == str(Util.FeValue.LATEST)
 
+        if Attrs.is_solana_app():
+            auth_data["ecosystem"] = EcoEnum.SOLANA.name
+        elif Attrs.is_soroban_app():
+            auth_data["ecosystem"] = EcoEnum.SOROBAN.name
+        else:
+            auth_data["ecosystem"] = EcoEnum.EVM.name
+
+        if Attrs.is_ranger_app():
+            auth_data["product"] = ProductEnum.RANGER.name
+        elif Attrs.is_sophy_app():
+            auth_data["product"] = ProductEnum.SOPHY.name
+        else:
+            auth_data["product"] = ProductEnum.PROVER.name
+
         if Attrs.is_evm_app() and self.context.cache is not None:
             auth_data["toolSceneCacheKey"] = self.context.cache
 

{certora_cli_alpha_master-20250508.17.30.185947 → certora_cli_alpha_master-20250519.9.10.855346}/certora_cli/CertoraProver/certoraContext.py

@@ -278,6 +278,8 @@ def get_args(args_list: Optional[List[str]] = None) -> CertoraContext:
     if Attrs.is_evm_app():
         validator.check_args_post_argparse()
         setup_cache(context)  # Here context.cache, context.user_defined_cache are set
+    if Attrs.is_rust_app():
+        validator.check_rust_args_post_argparse()
 
     attrs_to_relative(context)
     # Setup defaults (defaults are not recorded in conf file)

{certora_cli_alpha_master-20250508.17.30.185947 → certora_cli_alpha_master-20250519.9.10.855346}/certora_cli/CertoraProver/certoraContextAttributes.py

@@ -998,6 +998,24 @@ class EvmAttributes(AttrUtil.Attributes):
         disables_build_cache=False
     )
 
+    STORAGE_EXTENSION_ANNOTATION = AttrUtil.AttributeDefinition(
+        arg_type=AttrUtil.AttrArgType.BOOLEAN,
+        argparse_args={
+            'action': AttrUtil.STORE_TRUE
+        },
+        affects_build_cache_key=True,
+        disables_build_cache=False
+    )
+
+    EXTRACT_STORAGE_EXTENSION_ANNOTATION = AttrUtil.AttributeDefinition(
+        arg_type=AttrUtil.AttrArgType.BOOLEAN,
+        argparse_args={
+            'action': AttrUtil.STORE_TRUE
+        },
+        affects_build_cache_key=False,
+        disables_build_cache=False
+    )
+
     OPTIMISTIC_HASHING = AttrUtil.AttributeDefinition(
         arg_type=AttrUtil.AttrArgType.BOOLEAN,
         help_msg="Bound the length of data (with potentially unbounded length) to the value given in "
@@ -1854,3 +1872,6 @@ def is_evm_app() -> bool:
 
 def is_ranger_app() -> bool:
     return get_attribute_class() == RangerAttributes
+
+def is_sophy_app() -> bool:
+    return False  # wait for the tool to be added

{certora_cli_alpha_master-20250508.17.30.185947 → certora_cli_alpha_master-20250519.9.10.855346}/certora_cli/CertoraProver/certoraContextValidator.py

@@ -154,6 +154,14 @@ class CertoraContextValidator:
         elif value not in [True, False]:
             raise Util.CertoraUserInputError(f"value of {conf_key} {value} is not a boolean (true/false)")
 
+    def check_rust_args_post_argparse(self) -> None:
+        context = self.context
+        if context.files:
+            if context.build_script:
+                raise Util.CertoraUserInputError("'files' and 'build_script' cannot be both set for Rust projects")
+            if len(context.files) > 1:
+                raise Util.CertoraUserInputError("Rust projects must specify exactly one executable in 'files'.")
+
     def check_args_post_argparse(self) -> None:
         """
         Performs checks over the arguments after basic argparse parsing

certora_cli_alpha_master-20250519.9.10.855346/certora_cli/CertoraProver/erc7201.py

@@ -0,0 +1,45 @@
+#     The Certora Prover
+#     Copyright (C) 2025  Certora Ltd.
+#
+#     This program is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU General Public License as published by
+#     the Free Software Foundation, version 3 of the License.
+#
+#     This program is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU General Public License for more details.
+#
+#     You should have received a copy of the GNU General Public License
+#     along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from Crypto.Hash import keccak
+
+
+def calculate_keccak_hash(x: bytes) -> int:
+    """
+    Calculates the Keccak-256 hash of the input bytes and returns it as an integer.
+
+    Args:
+        x (bytes): The input bytes to be hashed.
+    Returns:
+        int: The Keccak-256 hash value as an integer.
+    """
+    k = keccak.new(digest_bits=256)
+    k.update(x)
+    return int(k.hexdigest(), base=16)
+
+def erc7201(x: bytes) -> int:
+    """
+    Hashes the input bytes using the Keccak-256 algorithm and returns
+    the result as an integer. The input is first hashed, then decremented
+    by 1, and the resulting hash is used to compute the final hash.
+    The final hash is masked to 256 bits and the last byte is cleared
+    (set to zero).
+
+    Args:
+        x (bytes): The input bytes to be hashed.
+    Returns:
+        int: The final hash value as an integer.
+    """
+    return calculate_keccak_hash((calculate_keccak_hash(x) - 1).to_bytes(32, byteorder='big')) & (~0xff)