cairo-lang 0.13.4a1__zip → 0.14.0__zip

{cairo-lang-0.13.4a1 → cairo-lang-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cairo-lang
-Version: 0.13.4a1
+Version: 0.14.0
 Summary: Compiler and runner for the Cairo language
 Home-page: https://cairo-lang.org/
 Author: Starkware
@@ -22,7 +22,7 @@ We recommend starting from [Setting up the environment](https://cairo-lang.org/d
 # Installation instructions
 
 You should be able to download the python package zip file directly from
-[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.13.4)
+[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.14.0)
 and install it using ``pip``.
 See [Setting up the environment](https://cairo-lang.org/docs/quickstart.html).
 
@@ -64,7 +64,6 @@ Once the docker image is built, you can fetch the python package zip file using:
 
 ```bash
 > container_id=$(docker create cairo)
-> docker cp ${container_id}:/app/cairo-lang-0.13.4.zip .
+> docker cp ${container_id}:/app/cairo-lang-0.14.0.zip .
 > docker rm -v ${container_id}
 ```
-

{cairo-lang-0.13.4a1 → cairo-lang-0.14.0}/README.md

@@ -12,7 +12,7 @@ We recommend starting from [Setting up the environment](https://cairo-lang.org/d
 # Installation instructions
 
 You should be able to download the python package zip file directly from
-[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.13.4)
+[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.14.0)
 and install it using ``pip``.
 See [Setting up the environment](https://cairo-lang.org/docs/quickstart.html).
 
@@ -54,7 +54,6 @@ Once the docker image is built, you can fetch the python package zip file using:
 
 ```bash
 > container_id=$(docker create cairo)
-> docker cp ${container_id}:/app/cairo-lang-0.13.4.zip .
+> docker cp ${container_id}:/app/cairo-lang-0.14.0.zip .
 > docker rm -v ${container_id}
 ```
-

{cairo-lang-0.13.4a1 → cairo-lang-0.14.0}/cairo_lang.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cairo-lang
-Version: 0.13.4a1
+Version: 0.14.0
 Summary: Compiler and runner for the Cairo language
 Home-page: https://cairo-lang.org/
 Author: Starkware
@@ -22,7 +22,7 @@ We recommend starting from [Setting up the environment](https://cairo-lang.org/d
 # Installation instructions
 
 You should be able to download the python package zip file directly from
-[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.13.4)
+[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.14.0)
 and install it using ``pip``.
 See [Setting up the environment](https://cairo-lang.org/docs/quickstart.html).
 
@@ -64,7 +64,6 @@ Once the docker image is built, you can fetch the python package zip file using:
 
 ```bash
 > container_id=$(docker create cairo)
-> docker cp ${container_id}:/app/cairo-lang-0.13.4.zip .
+> docker cp ${container_id}:/app/cairo-lang-0.14.0.zip .
 > docker rm -v ${container_id}
 ```
-

{cairo-lang-0.13.4a1 → cairo-lang-0.14.0}/cairo_lang.egg-info/SOURCES.txt

@@ -102,6 +102,7 @@ starkware/cairo/common/cairo_blake2s/__init__.py
 starkware/cairo/common/cairo_blake2s/blake2s.cairo
 starkware/cairo/common/cairo_blake2s/blake2s_utils.py
 starkware/cairo/common/cairo_blake2s/packed_blake2s.cairo
+starkware/cairo/common/cairo_ec_op/ec_op.cairo
 starkware/cairo/common/cairo_keccak/__init__.py
 starkware/cairo/common/cairo_keccak/keccak.cairo
 starkware/cairo/common/cairo_keccak/keccak_utils.py
@@ -126,6 +127,7 @@ starkware/cairo/common/secp256r1/bigint.cairo
 starkware/cairo/common/secp256r1/constants.cairo
 starkware/cairo/common/secp256r1/ec.cairo
 starkware/cairo/common/secp256r1/field.cairo
+starkware/cairo/common/simulate_builtin_keccak_with_cairo/simulate_keccak.cairo
 starkware/cairo/lang/VERSION
 starkware/cairo/lang/__init__.py
 starkware/cairo/lang/cairo_constants.py
@@ -369,10 +371,10 @@ starkware/starknet/compiler/v1/compile.py
 starkware/starknet/compiler/v1/compiler_exe_paths.py
 starkware/starknet/compiler/v1/experimental_libfuncs.json
 starkware/starknet/compiler/v1/mainnet_libfuncs.json
-starkware/starknet/compiler/v1/testnet_libfuncs.json
 starkware/starknet/compiler/v1/sierra-compiler-major-1/bin/starknet-compile
 starkware/starknet/compiler/v1/sierra-compiler-major-1/bin/starknet-sierra-compile
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/array.cairo
+starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/blake.cairo
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/boolean.cairo
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/box.cairo
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/byte_array.cairo
@@ -403,6 +405,7 @@ starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/panics.cairo
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/pedersen.cairo
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/poseidon.cairo
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/prelude.cairo
+starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/qm31.cairo
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/result.cairo
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/serde.cairo
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/sha256.cairo
@@ -414,7 +417,6 @@ starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/to_byte_array
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/traits.cairo
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/zeroable.cairo
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/starknet/account.cairo
-starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/starknet/address_helper.cairo
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/starknet/class_hash.cairo
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/starknet/contract_address.cairo
 starkware/starknet/compiler/v1/sierra-compiler-major-1/corelib/src/starknet/eth_address.cairo
@@ -433,15 +435,12 @@ starkware/starknet/core/aggregator/__init__.py
 starkware/starknet/core/aggregator/output_parser.py
 starkware/starknet/core/aggregator/utils.py
 starkware/starknet/core/os/__init__.py
-starkware/starknet/core/os/block_context.cairo
-starkware/starknet/core/os/builtins.cairo
+starkware/starknet/core/os/bl_syscall_handler.py
 starkware/starknet/core/os/constants.cairo
+starkware/starknet/core/os/deprecated_bl_syscall_handler.py
 starkware/starknet/core/os/deprecated_syscall_handler.py
-starkware/starknet/core/os/kzg_manager.py
-starkware/starknet/core/os/os.cairo
 starkware/starknet/core/os/os_logger.py
 starkware/starknet/core/os/os_utils.py
-starkware/starknet/core/os/output.cairo
 starkware/starknet/core/os/segment_utils.py
 starkware/starknet/core/os/starknet_builtins.json
 starkware/starknet/core/os/starknet_new_syscalls.json
@@ -456,35 +455,16 @@ starkware/starknet/core/os/contract_address/contract_address.py
 starkware/starknet/core/os/contract_class/__init__.py
 starkware/starknet/core/os/contract_class/class_hash.py
 starkware/starknet/core/os/contract_class/class_hash_utils.py
-starkware/starknet/core/os/contract_class/compiled_class.cairo
 starkware/starknet/core/os/contract_class/compiled_class_hash.py
 starkware/starknet/core/os/contract_class/compiled_class_hash_objects.py
-starkware/starknet/core/os/contract_class/compiled_class_hash_utils.py
-starkware/starknet/core/os/contract_class/contract_class.cairo
 starkware/starknet/core/os/contract_class/deprecated_class_hash.py
-starkware/starknet/core/os/contract_class/deprecated_compiled_class.cairo
 starkware/starknet/core/os/contract_class/utils.py
 starkware/starknet/core/os/data_availability/__init__.py
-starkware/starknet/core/os/data_availability/bls_field.cairo
-starkware/starknet/core/os/data_availability/bls_utils.py
-starkware/starknet/core/os/data_availability/commitment.cairo
-starkware/starknet/core/os/data_availability/compression.cairo
 starkware/starknet/core/os/data_availability/compression.py
-starkware/starknet/core/os/execution/deprecated_execute_entry_point.cairo
-starkware/starknet/core/os/execution/deprecated_execute_syscalls.cairo
-starkware/starknet/core/os/execution/execute_entry_point.cairo
-starkware/starknet/core/os/execution/execute_syscalls.cairo
-starkware/starknet/core/os/execution/execute_transactions.cairo
-starkware/starknet/core/os/execution/revert.cairo
-starkware/starknet/core/os/os_config/os_config.cairo
-starkware/starknet/core/os/state/aliases.cairo
-starkware/starknet/core/os/state/commitment.cairo
-starkware/starknet/core/os/state/output.cairo
-starkware/starknet/core/os/state/squash.cairo
-starkware/starknet/core/os/state/state.cairo
+starkware/starknet/core/os/execution/__init__.py
+starkware/starknet/core/os/execution/account_backward_compatibility.py
 starkware/starknet/core/os/transaction_hash/__init__.py
 starkware/starknet/core/os/transaction_hash/deprecated_transaction_hash.py
-starkware/starknet/core/os/transaction_hash/transaction_hash.cairo
 starkware/starknet/core/os/transaction_hash/transaction_hash.py
 starkware/starknet/core/test_contract/__init__.py
 starkware/starknet/core/test_contract/delegate_proxy.json
@@ -550,20 +530,12 @@ starkware/starknet/services/api/gateway/gateway_client.py
 starkware/starknet/services/api/gateway/transaction.py
 starkware/starknet/services/api/gateway/transaction_schema.py
 starkware/starknet/services/api/gateway/transaction_utils.py
-starkware/starknet/services/utils/__init__.py
-starkware/starknet/services/utils/sequencer_api_utils.py
 starkware/starknet/storage/__init__.py
 starkware/starknet/storage/starknet_storage.py
-starkware/starknet/third_party/__init__.py
-starkware/starknet/third_party/open_zeppelin/__init__.py
-starkware/starknet/third_party/open_zeppelin/account.json
-starkware/starknet/third_party/open_zeppelin/starknet_contracts.py
 starkware/starknet/utils/__init__.py
 starkware/starknet/utils/api_utils.py
 starkware/starknet/wallets/__init__.py
 starkware/starknet/wallets/account.py
-starkware/starknet/wallets/open_zeppelin.py
-starkware/starknet/wallets/signer.py
 starkware/starknet/wallets/starknet_context.py
 starkware/starkware_utils/__init__.py
 starkware/starkware_utils/config_base.py
@@ -606,4 +578,5 @@ starkware/storage/gated_storage.py
 starkware/storage/metrics.py
 starkware/storage/names.py
 starkware/storage/storage.py
+starkware/storage/storage_conflict.py
 starkware/storage/storage_utils.py

{cairo-lang-0.13.4a1 → cairo-lang-0.14.0}/cairo_lang.egg-info/requires.txt

@@ -10,7 +10,7 @@ lark
 marshmallow-dataclass==8.6.1
 marshmallow-enum
 marshmallow-oneofschema
-marshmallow>=3.2.1
+marshmallow<4.0,>=3.13.0
 mpmath
 numpy
 pipdeptree

{cairo-lang-0.13.4a1 → cairo-lang-0.14.0}/requirements.txt

@@ -10,7 +10,7 @@ lark
 marshmallow-dataclass==8.6.1
 marshmallow-enum
 marshmallow-oneofschema
-marshmallow>=3.2.1
+marshmallow>=3.13.0,<4.0
 mpmath
 numpy
 pipdeptree

{cairo-lang-0.13.4a1 → cairo-lang-0.14.0}/services/everest/definitions/fields.py

@@ -17,6 +17,7 @@ from starkware.starkware_utils.validated_fields import (
     OptionalField,
     RangeValidatedField,
     ValidatedField,
+    ValidatedIntFormatter,
 )
 
 # Fields data: validation data, dataclass metadata.
@@ -75,17 +76,17 @@ EthAddressIntField = RangeValidatedField(
     upper_bound=constants.ETH_ADDRESS_UPPER_BOUND,
     name="Ethereum address",
     error_code=StarkErrorCode.OUT_OF_RANGE_ETH_ADDRESS,
-    formatter=None,
+    formatter=ValidatedIntFormatter.INT,
 )
 
-EthAddressHexField = dataclasses.replace(EthAddressIntField, formatter=hex)
+EthAddressHexField = dataclasses.replace(EthAddressIntField, formatter=ValidatedIntFormatter.HEX)
 
 FeltField = RangeValidatedField(
     lower_bound=0,
     upper_bound=FIELD_PRIME,
     name="Field element",
     error_code=StarkErrorCode.OUT_OF_RANGE_FIELD_ELEMENT,
-    formatter=hex,
+    formatter=ValidatedIntFormatter.HEX,
 )
 
 OptionalFeltField = OptionalField(field=FeltField, none_probability=0)
@@ -94,14 +95,16 @@ felt_as_hex_list_metadata = dict(marshmallow_field=mfields.List(FeltField.get_ma
 
 
 def get_bounded_int_range_validator(
-    lower_bound: int = 0, upper_bound: int = FIELD_PRIME
+    lower_bound: int = 0,
+    upper_bound: int = FIELD_PRIME,
+    formatter: ValidatedIntFormatter = ValidatedIntFormatter.HEX,
 ) -> RangeValidatedField:
     return RangeValidatedField(
         lower_bound=lower_bound,
         upper_bound=upper_bound,
         name=f"Integer in range [{lower_bound}, {upper_bound})",
         error_code=StarkErrorCode.OUT_OF_RANGE_FIELD_ELEMENT,
-        formatter=hex,
+        formatter=formatter,
     )
 
 

{cairo-lang-0.13.4a1 → cairo-lang-0.14.0}/setup.py

@@ -21,6 +21,7 @@ setuptools.setup(
     setup_requires=["wheel"],
     url="https://cairo-lang.org/",
     package_data={
+        "starkware.cairo": ["builtin_selection/*.cairo"],
         "starkware.cairo.common": ["*.cairo", "*/*.cairo"],
         "starkware.cairo.lang.compiler": ["cairo.ebnf", "lib/*.cairo"],
         "starkware.cairo.lang.migrators": ["*.ebnf"],
@@ -32,6 +33,7 @@ setuptools.setup(
             "common/*.cairo",
             "definitions/*.yml",
             "definitions/versioned_constants.json",
+            "builtins/segment_arena/segment_arena.cairo",
         ],
         "starkware.starknet.compiler.v1": [
             "*.json",

{cairo-lang-0.13.4a1 → cairo-lang-0.14.0}/starkware/cairo/bootloaders/generate_fact.py

@@ -10,7 +10,7 @@ from starkware.cairo.bootloaders.fact_topology import (
     FactInfo,
     get_fact_topology_from_additional_data,
 )
-from starkware.cairo.bootloaders.hash_program import compute_program_hash_chain
+from starkware.cairo.bootloaders.hash_program import HashFunction, compute_program_hash_chain
 from starkware.cairo.lang.vm.cairo_pie import CairoPie
 from starkware.cairo.lang.vm.relocatable import MaybeRelocatable, RelocatableValue
 
@@ -37,12 +37,15 @@ def get_program_output(cairo_pie: CairoPie) -> List[int]:
 def get_cairo_pie_fact_info(
     cairo_pie: CairoPie,
     program_hash: Optional[int] = None,
+    program_output: Optional[List[int]] = None,
     aggregator: bool = False,
 ) -> FactInfo:
     """
     Generates the fact of the Cairo program of cairo_pie. Returns the cairo-pie fact info.
     """
-    program_output = get_program_output(cairo_pie=cairo_pie)
+    if program_output is None:
+        program_output = get_program_output(cairo_pie=cairo_pie)
+
     fact_topology = get_fact_topology_from_additional_data(
         output_size=len(program_output),
         output_builtin_additional_data=cairo_pie.additional_data["output_builtin"],
@@ -75,4 +78,6 @@ def get_cairo_pie_fact_info(
 
 
 def get_program_hash(cairo_pie: CairoPie) -> int:
-    return compute_program_hash_chain(program=cairo_pie.metadata.program, use_poseidon=False)
+    return compute_program_hash_chain(
+        program=cairo_pie.metadata.program, program_hash_function=HashFunction.PEDERSEN
+    )

cairo-lang-0.14.0/starkware/cairo/bootloaders/hash_program.py

@@ -0,0 +1,93 @@
+import argparse
+import json
+from enum import Enum
+
+from starkware.cairo.common.cairo_blake2s.blake2s_utils import calculate_blake2s_hash_from_felt252s
+from starkware.cairo.common.hash_chain import compute_hash_chain
+from starkware.cairo.lang.compiler.program import Program, ProgramBase
+from starkware.cairo.lang.version import __version__
+from starkware.cairo.lang.vm.crypto import get_crypto_lib_context_manager, poseidon_hash_many
+from starkware.python.utils import from_bytes
+
+
+class HashFunction(Enum):
+    """
+    A hash function. These can be used e.g. for hashing a program within the bootloader.
+    """
+
+    PEDERSEN = 0
+    POSEIDON = 1
+    BLAKE = 2
+
+
+def compute_program_hash_chain(
+    program: ProgramBase,
+    program_hash_function: HashFunction,
+    bootloader_version=0,
+    encode_blake2s_input: bool = False,
+    little_endian_for_blake2s: bool = True,
+):
+    """
+    Computes a hash chain over a program, including the length of the data chain.
+    If `encode_blake2s_input` is True, the data chain is encoded according to the specification
+    documented inside the `calculate_blake2s_hash_from_felt252s` function.
+    If `little_endian_for_blake2s` is True, the blake input is encoded in little-endian u32s.
+    """
+    builtin_list = [from_bytes(builtin.encode("ascii")) for builtin in program.builtins]
+    # The program header below is missing the data length, which is later added to the data_chain.
+    program_header = [bootloader_version, program.main, len(program.builtins)] + builtin_list
+    data_chain = program_header + program.data
+
+    if program_hash_function == HashFunction.POSEIDON:
+        return poseidon_hash_many(data_chain)
+    elif program_hash_function == HashFunction.PEDERSEN:
+        return compute_hash_chain([len(data_chain)] + data_chain)
+    else:
+        assert program_hash_function == HashFunction.BLAKE
+        return calculate_blake2s_hash_from_felt252s(
+            data=data_chain,
+            encode=encode_blake2s_input,
+            little_endian=little_endian_for_blake2s,
+            prime=program.prime,
+        )
+
+
+def main():
+    parser = argparse.ArgumentParser(description="A tool to compute the hash of a cairo program")
+    parser.add_argument("-v", "--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument(
+        "--program",
+        type=argparse.FileType("r"),
+        required=True,
+        help="The name of the program json file.",
+    )
+    parser.add_argument(
+        "--flavor",
+        type=str,
+        default="Release",
+        choices=["Debug", "Release", "RelWithDebInfo"],
+        help="Build flavor",
+    )
+    parser.add_argument(
+        "--program-hash-function",
+        type=str,
+        choices=[hf.name.lower() for hf in HashFunction],
+        default=HashFunction.PEDERSEN.name.lower(),
+        help="Hash function to be used. Options: pedersen, poseidon, blake. Default: pedersen.",
+    )
+    args = parser.parse_args()
+
+    with get_crypto_lib_context_manager(args.flavor):
+        program = Program.Schema().load(json.load(args.program))
+        print(
+            hex(
+                compute_program_hash_chain(
+                    program=program,
+                    program_hash_function=HashFunction[args.program_hash_function.upper()],
+                )
+            )
+        )
+
+
+if __name__ == "__main__":
+    main()

{cairo-lang-0.13.4a1 → cairo-lang-0.14.0}/starkware/cairo/bootloaders/program_hash_test_utils.py

@@ -1,7 +1,7 @@
 import json
 from typing import Any, Callable, Optional
 
-from starkware.cairo.bootloaders.hash_program import compute_program_hash_chain
+from starkware.cairo.bootloaders.hash_program import HashFunction, compute_program_hash_chain
 from starkware.cairo.lang.compiler.program import Program
 
 
@@ -17,7 +17,11 @@ def run_generate_hash_test(
     If post_process is given, it may add additional fields to the expected JSON.
     """
     compiled_program = Program.Schema().load(json.load(open(program_path)))
-    program_hash = hex(compute_program_hash_chain(program=compiled_program, use_poseidon=False))
+    program_hash = hex(
+        compute_program_hash_chain(
+            program=compiled_program, program_hash_function=HashFunction.PEDERSEN
+        )
+    )
     program_hash_key = "program_hash"
 
     expected_json = {program_hash_key: program_hash}

{cairo-lang-0.13.4a1 → cairo-lang-0.14.0}/starkware/cairo/common/cairo_blake2s/blake2s.cairo

@@ -565,3 +565,186 @@ func blake2s_felts{range_check_ptr, bitwise_ptr: BitwiseBuiltin*, blake2s_ptr: f
     let (res) = blake2s(data=data_start, n_bytes=n_elements * 32);
     return (res=res);
 }
+
+// Takes an array of `packed_values_len` felt252s at `packed_values` and encodes them into an array
+// of u32s at `unpacked_u32s` in the following way:
+//  * If a felt is less than 2^63, it's unpacked to 2 felts, each representing 32 bits.
+//  * Otherwise, it's unpacked into 8 felts, each under 2^32, where the most significant
+//    limb has its MSB set (Note that the prime is less than 2^255 so the MSB could not be
+//    set prior to this intervention).
+// All 32-bit limbs are arranged in big-endian order.
+// Returns the size of the unpacked array in felts.
+// Assumes:
+//  * All output felts in `upnacked_u32s` are extrenally verified to be in [0, 2^32).
+// Note: This function can nondeterministically choose between several encodings of felts,
+//      x < PRIME can be encoded as x + PRIME, x + 2 * PRIME, etc. The canonical encoding is
+//      given when x < PRIME.
+func encode_felt252_to_u32s{range_check_ptr: felt}(
+    packed_values_len: felt, packed_values: felt*, unpacked_u32s: felt*
+) -> felt {
+    alloc_locals;
+
+    local U63_MAX = 2 ** 63 - 1;
+    local EXP31 = 2 ** 31;
+    local end = cast(packed_values, felt) + packed_values_len;
+
+    %{
+        offset = 0
+        for i in range(ids.packed_values_len):
+            val = (memory[ids.packed_values + i] % PRIME)
+            val_len = 2 if val < 2**63 else 8
+            if val_len == 8:
+                val += 2**255
+            for i in range(val_len - 1, -1, -1):
+                val, memory[ids.unpacked_u32s + offset + i] = divmod(val, 2**32)
+            assert val == 0
+            offset += val_len
+    %}
+    tempvar out = unpacked_u32s;
+    tempvar packed_values = packed_values;
+    tempvar range_check_ptr = range_check_ptr;
+
+    loop:
+    // Guess if number is small or big.
+    if (nondet %{ (ids.end != ids.packed_values) and (memory[ids.packed_values] < 2**63) %} != 0) {
+        // Unpack small felt.
+
+        tempvar current_val = packed_values[0];
+        // Assert that the value is in [0, 2^63).
+        assert [range_check_ptr] = U63_MAX - current_val;
+        // Assert that the limbs represent the number.
+        assert current_val = out[1] + 2 ** 32 * out[0];
+
+        tempvar out = &out[2];
+        tempvar packed_values = &packed_values[1];
+        tempvar range_check_ptr = range_check_ptr + 1;
+        jmp loop;
+    }
+
+    if (end - cast(packed_values, felt) == 0) {
+        return out - unpacked_u32s;
+    }
+
+    // Handle big felt.
+    // Assert that the top limb is over 2^31, as its MSB is artificially set for encoding.
+    tempvar raw_out_0 = out[0] - EXP31;
+    assert [range_check_ptr] = raw_out_0;
+    // Assert that the limbs represent the number. Set the MSB of the most significant limb.
+    assert packed_values[0] = (
+        (out[7] + (2 ** 32 * out[6])) +
+        2 ** (32 * 2) * (out[5] + 2 ** 32 * out[4]) +
+        2 ** (32 * 4) * (out[3] + 2 ** 32 * out[2]) +
+        2 ** (32 * 6) * (out[1] + 2 ** 32 * raw_out_0)
+    );
+
+    tempvar out = &out[8];
+    tempvar packed_values = &packed_values[1];
+    tempvar range_check_ptr = range_check_ptr + 1;
+    jmp loop;
+}
+
+const OP1_AP = 4;
+const BLAKE2S_OPCODE_EXT = 1;
+const BLAKE2S_FINALIZE_OPCODE_EXT = 2;
+const BLAKE2S_AP_FLAGS = OP1_AP * (2 ** 2);
+
+const OFF_MINUS_1 = 2 ** 15 - 1;
+const OFF_MINUS_2 = 2 ** 15 - 2;
+const OFF_MINUS_3 = 2 ** 15 - 3;
+const OFF_MINUS_4 = 2 ** 15 - 4;
+
+const COUNTER_OFFSET = 1;
+const STATE_OFFSET = 2 ** 16;
+const MESSAGE_OFFSET = 2 ** 32;
+const FLAGS_OFFSET = 2 ** 48;
+const OPCODE_EXT_OFFSET = 2 ** 63;
+
+const BLAKE2S_INSTRUCTION = OFF_MINUS_1 * COUNTER_OFFSET + OFF_MINUS_4 * STATE_OFFSET +
+    OFF_MINUS_3 * MESSAGE_OFFSET + BLAKE2S_AP_FLAGS * FLAGS_OFFSET + BLAKE2S_OPCODE_EXT *
+    OPCODE_EXT_OFFSET;
+const BLAKE2S_FINALIZE_INSTRUCTION = OFF_MINUS_1 * COUNTER_OFFSET + OFF_MINUS_3 * STATE_OFFSET +
+    OFF_MINUS_2 * MESSAGE_OFFSET + BLAKE2S_AP_FLAGS * FLAGS_OFFSET + BLAKE2S_FINALIZE_OPCODE_EXT *
+    OPCODE_EXT_OFFSET;
+
+// Computes blake2s of `input` of size `len` felts, representing 32 bits each.
+// Note: this function guarantees that len > 0.
+func blake_with_opcode{range_check_ptr}(len: felt, data: felt*, out: felt*) {
+    alloc_locals;
+
+    let (local state: felt*) = alloc();
+    assert state[0] = 0x6B08E647;  // IV[0] ^ 0x01010020 (config: no key, 32 bytes output).
+    assert state[1] = 0xBB67AE85;
+    assert state[2] = 0x3C6EF372;
+    assert state[3] = 0xA54FF53A;
+    assert state[4] = 0x510E527F;
+    assert state[5] = 0x9B05688C;
+    assert state[6] = 0x1F83D9AB;
+    assert state[7] = 0x5BE0CD19;
+
+    // Express the length in bytes, subtract the remainder for finalize.
+    let (_, rem) = unsigned_div_rem(len - 1, 16);
+    local rem = rem + 1;
+    local len_in_bytes = (len - rem) * 4;
+
+    local range_check_ptr = range_check_ptr;
+
+    // Copy remaining data and pad with zeroes.
+    let (local final_data: felt*) = alloc();
+    memcpy(final_data, &data[len - rem], rem);
+    memset(&final_data[rem], 0, 16 - rem);
+
+    tempvar counter = 0;
+    tempvar state = state;
+    tempvar data = data;
+
+    loop:
+    if (counter - len_in_bytes == 0) {
+        // Add remainder bytes to counter.
+        tempvar counter = counter + (rem * 4);
+        [ap] = state, ap++;
+        [ap] = final_data, ap++;
+        [ap] = counter, ap++;
+        [ap] = out;
+        dw BLAKE2S_FINALIZE_INSTRUCTION;
+        // Increment AP after blake opcode.
+        ap += 1;
+
+        let range_check_ptr = [fp + 3];
+        return ();
+    }
+
+    tempvar counter = counter + 64;
+
+    // Blake output pointer / the next state.
+    [ap] = &state[8];
+    dw BLAKE2S_INSTRUCTION;
+
+    let state = cast([ap - 4], felt*);
+    let data = cast([ap - 3], felt*);
+
+    // Increment AP after blake opcode.
+    ap += 1;
+
+    tempvar data = data + 16;
+    jmp loop;
+}
+
+// Given `data_len` felt252s at `data`, encodes them as u32s as defined in `encode_felt252_to_u32s`
+// and computes the blake2s hash of the result using the dedicated opcodes.
+// The 256 bit result is then returned as a felt252 (i.e. modulo PRIME).
+func encode_felt252_data_and_calc_blake_hash{range_check_ptr: felt}(
+    data_len: felt, data: felt*
+) -> (hash: felt) {
+    alloc_locals;
+    let (local encoded_data: felt*) = alloc();
+    let encoded_data_len = encode_felt252_to_u32s(
+        packed_values_len=data_len, packed_values=data, unpacked_u32s=encoded_data
+    );
+    let (local blake_output: felt*) = alloc();
+    blake_with_opcode(len=encoded_data_len, data=encoded_data, out=blake_output);
+    return (
+        hash=blake_output[7] * 2 ** 224 + blake_output[6] * 2 ** 192 + blake_output[5] * 2 ** 160 +
+        blake_output[4] * 2 ** 128 + blake_output[3] * 2 ** 96 + blake_output[2] * 2 ** 64 +
+        blake_output[1] * 2 ** 32 + blake_output[0],
+    );
+}