cairo-lang 0.11.1a0__zip → 0.11.2__zip

{cairo-lang-0.11.1a0 → cairo-lang-0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cairo-lang
-Version: 0.11.1a0
+Version: 0.11.2
 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.11.0.2)
+[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.11.2)
 and install it using ``pip``.
 See [Setting up the environment](https://cairo-lang.org/docs/quickstart.html).
 
@@ -64,7 +64,7 @@ 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.11.1.zip .
+> docker cp ${container_id}:/app/cairo-lang-0.11.2.zip .
 > docker rm -v ${container_id}
 ```
 

{cairo-lang-0.11.1a0 → cairo-lang-0.11.2}/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.11.0.2)
+[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.11.2)
 and install it using ``pip``.
 See [Setting up the environment](https://cairo-lang.org/docs/quickstart.html).
 
@@ -54,7 +54,7 @@ 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.11.1.zip .
+> docker cp ${container_id}:/app/cairo-lang-0.11.2.zip .
 > docker rm -v ${container_id}
 ```
 

{cairo-lang-0.11.1a0 → cairo-lang-0.11.2}/cairo_lang.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cairo-lang
-Version: 0.11.1a0
+Version: 0.11.2
 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.11.0.2)
+[github](https://github.com/starkware-libs/cairo-lang/releases/tag/v0.11.2)
 and install it using ``pip``.
 See [Setting up the environment](https://cairo-lang.org/docs/quickstart.html).
 
@@ -64,7 +64,7 @@ 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.11.1.zip .
+> docker cp ${container_id}:/app/cairo-lang-0.11.2.zip .
 > docker rm -v ${container_id}
 ```
 

{cairo-lang-0.11.1a0 → cairo-lang-0.11.2}/cairo_lang.egg-info/SOURCES.txt

@@ -352,6 +352,41 @@ starkware/starknet/compiler/v1/compile.py
 starkware/starknet/compiler/v1/mainnet_libfuncs.json
 starkware/starknet/compiler/v1/testnet2_libfuncs.json
 starkware/starknet/compiler/v1/testnet_libfuncs.json
+starkware/starknet/compiler/v1/bin/starknet-compile
+starkware/starknet/compiler/v1/bin/starknet-sierra-compile
+starkware/starknet/compiler/v1/corelib/src/array.cairo
+starkware/starknet/compiler/v1/corelib/src/box.cairo
+starkware/starknet/compiler/v1/corelib/src/clone.cairo
+starkware/starknet/compiler/v1/corelib/src/cmp.cairo
+starkware/starknet/compiler/v1/corelib/src/debug.cairo
+starkware/starknet/compiler/v1/corelib/src/dict.cairo
+starkware/starknet/compiler/v1/corelib/src/ec.cairo
+starkware/starknet/compiler/v1/corelib/src/ecdsa.cairo
+starkware/starknet/compiler/v1/corelib/src/gas.cairo
+starkware/starknet/compiler/v1/corelib/src/hash.cairo
+starkware/starknet/compiler/v1/corelib/src/integer.cairo
+starkware/starknet/compiler/v1/corelib/src/internal.cairo
+starkware/starknet/compiler/v1/corelib/src/keccak.cairo
+starkware/starknet/compiler/v1/corelib/src/lib.cairo
+starkware/starknet/compiler/v1/corelib/src/nullable.cairo
+starkware/starknet/compiler/v1/corelib/src/option.cairo
+starkware/starknet/compiler/v1/corelib/src/poseidon.cairo
+starkware/starknet/compiler/v1/corelib/src/result.cairo
+starkware/starknet/compiler/v1/corelib/src/serde.cairo
+starkware/starknet/compiler/v1/corelib/src/starknet.cairo
+starkware/starknet/compiler/v1/corelib/src/test.cairo
+starkware/starknet/compiler/v1/corelib/src/testing.cairo
+starkware/starknet/compiler/v1/corelib/src/traits.cairo
+starkware/starknet/compiler/v1/corelib/src/zeroable.cairo
+starkware/starknet/compiler/v1/corelib/src/starknet/class_hash.cairo
+starkware/starknet/compiler/v1/corelib/src/starknet/contract_address.cairo
+starkware/starknet/compiler/v1/corelib/src/starknet/eth_address.cairo
+starkware/starknet/compiler/v1/corelib/src/starknet/event.cairo
+starkware/starknet/compiler/v1/corelib/src/starknet/info.cairo
+starkware/starknet/compiler/v1/corelib/src/starknet/secp256k1.cairo
+starkware/starknet/compiler/v1/corelib/src/starknet/storage_access.cairo
+starkware/starknet/compiler/v1/corelib/src/starknet/syscalls.cairo
+starkware/starknet/compiler/v1/corelib/src/starknet/testing.cairo
 starkware/starknet/core/__init__.py
 starkware/starknet/core/os/__init__.py
 starkware/starknet/core/os/deprecated_syscall_handler.py

cairo-lang-0.11.2/starkware/cairo/lang/VERSION

@@ -0,0 +1 @@
+0.11.2

{cairo-lang-0.11.1a0 → cairo-lang-0.11.2}/starkware/cairo/lang/create_cairo_lang_zip.py

@@ -10,6 +10,8 @@ import sys
 
 from starkware.python.utils import get_build_dir_path
 
+COMPILER_DIR = get_build_dir_path("../cairo-compiler-archive-1.1.0")
+
 INIT_FILE_CONTENT = "__path__ = __import__('pkgutil').extend_path(__path__, __name__)\n"
 
 
@@ -40,6 +42,17 @@ if __name__ == "__main__":
     shutil.copy("scripts/requirements-gen.txt", os.path.join(dst_dir, "requirements.txt"))
     shutil.copy("README.md", dst_dir)
 
+    # Copy cairo compiler files.
+    # They are generated by Bazel and must be copied to be available for the package.
+    shutil.copytree(
+        os.path.join(COMPILER_DIR, "bin"),
+        os.path.join(dst_dir, "starkware/starknet/compiler/v1/bin"),
+    )
+    shutil.copytree(
+        os.path.join(COMPILER_DIR, "corelib"),
+        os.path.join(dst_dir, "starkware/starknet/compiler/v1/corelib"),
+    )
+
     # Run setup.py.
     subprocess.check_call([sys.executable, "setup.py", "sdist", "--format=zip"], cwd=dst_dir)
 

{cairo-lang-0.11.1a0 → cairo-lang-0.11.2}/starkware/cairo/lang/vm/cairo_pie.py

@@ -4,21 +4,22 @@ A CairoPie represents a position independent execution of a Cairo program.
 
 import copy
 import dataclasses
+import functools
 import io
 import json
 import math
 import zipfile
 from dataclasses import field
-from typing import Any, ClassVar, Dict, List, Type
+from typing import Any, ClassVar, Dict, List, Mapping, Optional, Tuple, Type
 
 import marshmallow
 import marshmallow.fields as mfields
 import marshmallow_dataclass
 
 from starkware.cairo.lang.compiler.program import StrippedProgram, is_valid_builtin_name
-from starkware.cairo.lang.vm.memory_dict import MemoryDict
+from starkware.cairo.lang.vm.memory_dict import MemoryDict, RelocateValueFunc
 from starkware.cairo.lang.vm.memory_segments import is_valid_memory_addr, is_valid_memory_value
-from starkware.cairo.lang.vm.relocatable import RelocatableValue
+from starkware.cairo.lang.vm.relocatable import MaybeRelocatable, RelocatableValue, relocate_value
 from starkware.python.utils import add_counters, multiply_counter_by_scalar, sub_counters
 from starkware.starkware_utils.marshmallow_dataclass_fields import additional_metadata
 
@@ -279,12 +280,68 @@ class CairoPie:
 
         return cls(metadata, memory, additional_data, execution_resources, version)
 
-    def to_file(self, file):
+    def merge_extra_segments(self) -> Tuple[List[SegmentInfo], Dict[int, RelocatableValue]]:
+        """
+        Merges extra_segments to one segment.
+        Returns a tuple of the new extra_segments (which contains a single merged segment) and a
+        dictionary from old segment index to its offset in the new segment.
+        """
+        assert len(self.metadata.extra_segments) > 0
+
+        # Take the index of the segment from the first merged segment.
+        new_segment_index = self.metadata.extra_segments[0].index
+        segment_offsets = {}
+        segments_accumulated_size = 0
+        for segment in self.metadata.extra_segments:
+            segment_offsets[segment.index] = RelocatableValue(
+                new_segment_index, segments_accumulated_size
+            )
+            segments_accumulated_size += segment.size
+        return (
+            [SegmentInfo(index=new_segment_index, size=segments_accumulated_size)],
+            segment_offsets,
+        )
+
+    def get_relocate_value_func(
+        self, segment_offsets: Optional[Mapping[int, MaybeRelocatable]]
+    ) -> Optional[RelocateValueFunc]:
+        """
+        Returns a relocate_value function that relocates values according to the given segment
+        offsets.
+        """
+        if segment_offsets is None:
+            return None
+
+        return functools.partial(
+            relocate_value,
+            segment_offsets=segment_offsets,
+            prime=self.program.prime,
+            # The known segments (such as builtins) are missing since we do not want to relocate
+            # them.
+            allow_missing_segments=True,
+        )
+
+    def to_file(self, file, merge_extra_segments: bool = False):
+        extra_segments, segment_offsets = (
+            self.merge_extra_segments()
+            if merge_extra_segments and len(self.metadata.extra_segments) > 0
+            else (None, None)
+        )
+        metadata = self.metadata
+        if extra_segments is not None:
+            metadata = dataclasses.replace(metadata, extra_segments=extra_segments)
         with zipfile.ZipFile(file, mode="w", compression=zipfile.ZIP_DEFLATED) as zf:
             with zf.open(self.METADATA_FILENAME, "w") as fp:
-                fp.write(json.dumps(CairoPieMetadata.Schema().dump(self.metadata)).encode("ascii"))
+                fp.write(json.dumps(CairoPieMetadata.Schema().dump(metadata)).encode("ascii"))
             with zf.open(self.MEMORY_FILENAME, "w") as fp:
-                fp.write(self.memory.serialize(self.metadata.field_bytes))
+                fp.write(
+                    self.memory.serialize(
+                        field_bytes=self.metadata.field_bytes,
+                        relocate_value=self.get_relocate_value_func(
+                            segment_offsets=segment_offsets
+                        ),
+                    )
+                )
             with zf.open(self.ADDITIONAL_DATA_FILENAME, "w") as fp:
                 fp.write(json.dumps(self.additional_data).encode("ascii"))
             with zf.open(self.EXECUTION_RESOURCES_FILENAME, "w") as fp:

{cairo-lang-0.11.1a0 → cairo-lang-0.11.2}/starkware/cairo/lang/vm/memory_dict.py

@@ -32,6 +32,8 @@ MemoryDictInitializer = Optional[
     ]
 ]
 
+RelocateValueFunc = Callable[[MaybeRelocatable], MaybeRelocatable]
+
 
 class MemoryDict:
     """
@@ -213,14 +215,17 @@ class MemoryDict:
         """
         self.data[addr] = value
 
-    def serialize(self, field_bytes):
+    def serialize(self, field_bytes, relocate_value: Optional[RelocateValueFunc] = None):
         assert (
             len(self.relocation_rules) == 0
         ), "Cannot serialize a MemoryDict with active segment relocation rules."
 
+        if relocate_value is None:
+            relocate_value = lambda val: val
+
         return b"".join(
-            RelocatableValue.to_bytes(addr, ADDR_SIZE_IN_BYTES, "little")
-            + RelocatableValue.to_bytes(value, field_bytes, "little")
+            RelocatableValue.to_bytes(relocate_value(addr), ADDR_SIZE_IN_BYTES, "little")
+            + RelocatableValue.to_bytes(relocate_value(value), field_bytes, "little")
             for addr, value in self.items()
         )
 

{cairo-lang-0.11.1a0 → cairo-lang-0.11.2}/starkware/python/utils.py

@@ -168,6 +168,26 @@ def get_source_dir_path(rel_path: str = "", default_value: Optional[str] = None)
     raise Exception(f"Failed to get source path for {rel_path}.")
 
 
+def deduce_absolute_path(path: str) -> str:
+    """
+    Returns the given path if it is absolute, and otherwise joins it with the current working
+    directory.
+    This function is useful when using Bazel, which changes the current working directory.
+
+    Important note: This function assumes that the code is being run using Bazel.
+    """
+
+    if os.path.isabs(path):
+        return path
+
+    # The path is considered to be relative to the current working directory.
+    build_working_directory = os.getenv("BUILD_WORKING_DIRECTORY")
+    assert (
+        build_working_directory is not None
+    ), "Could not deduce your working directory path; please run your code using Bazel."
+    return os.path.join(build_working_directory, path)
+
+
 def assert_same_and_get(*args):
     """
     Verifies that all the arguments are the same, and returns this value.

{cairo-lang-0.11.1a0 → cairo-lang-0.11.2}/starkware/starknet/business_logic/state/state_api_objects.py

@@ -28,7 +28,7 @@ class BlockInfo(ValidatedMarshmallowDataclass):
     # The sequencer address of this block.
     sequencer_address: Optional[int] = field(metadata=fields.optional_sequencer_address_metadata)
 
-    # The version of StarkNet system (e.g. "0.11.1").
+    # The version of Starknet system (e.g. "0.11.2").
     starknet_version: Optional[str] = field(metadata=fields.starknet_version_metadata)
 
     @classmethod

{cairo-lang-0.11.1a0 → cairo-lang-0.11.2}/starkware/starknet/compiler/v1/compile.py

@@ -14,7 +14,7 @@ if "RUNFILES_DIR" in os.environ:
 
     r = runfiles.Create()
 
-    COMPILER_DIR = r.Rlocation("cairo-compiler-archive-1.0.0/bin")
+    COMPILER_DIR = r.Rlocation("cairo-compiler-archive-1.1.0/bin")
 else:
     COMPILER_DIR = os.path.join(os.path.dirname(__file__), "bin")
 

cairo-lang-0.11.2/starkware/starknet/compiler/v1/corelib/src/array.cairo

@@ -0,0 +1,162 @@
+use traits::IndexView;
+
+use box::BoxTrait;
+use gas::withdraw_gas;
+use option::OptionTrait;
+
+extern type Array<T>;
+extern fn array_new<T>() -> Array<T> nopanic;
+extern fn array_append<T>(ref arr: Array<T>, value: T) nopanic;
+extern fn array_pop_front<T>(ref arr: Array<T>) -> Option<Box<T>> nopanic;
+extern fn array_snapshot_pop_front<T>(ref arr: @Array<T>) -> Option<Box<@T>> nopanic;
+extern fn array_snapshot_pop_back<T>(ref arr: @Array<T>) -> Option<Box<@T>> nopanic;
+#[panic_with('Index out of bounds', array_at)]
+extern fn array_get<T>(
+    arr: @Array<T>, index: usize
+) -> Option<Box<@T>> implicits(RangeCheck) nopanic;
+extern fn array_slice<T>(
+    arr: @Array<T>, start: usize, length: usize
+) -> Option<@Array<T>> implicits(RangeCheck) nopanic;
+extern fn array_len<T>(arr: @Array<T>) -> usize nopanic;
+
+trait ArrayTrait<T> {
+    fn new() -> Array<T>;
+    fn append(ref self: Array<T>, value: T);
+    fn pop_front(ref self: Array<T>) -> Option<T> nopanic;
+    fn get(self: @Array<T>, index: usize) -> Option<Box<@T>>;
+    fn at(self: @Array<T>, index: usize) -> @T;
+    fn len(self: @Array<T>) -> usize;
+    fn is_empty(self: @Array<T>) -> bool;
+    fn span(self: @Array<T>) -> Span<T>;
+}
+impl ArrayImpl<T> of ArrayTrait<T> {
+    #[inline(always)]
+    fn new() -> Array<T> {
+        array_new()
+    }
+    #[inline(always)]
+    fn append(ref self: Array<T>, value: T) {
+        array_append(ref self, value)
+    }
+    #[inline(always)]
+    fn pop_front(ref self: Array<T>) -> Option<T> nopanic {
+        match array_pop_front(ref self) {
+            Option::Some(x) => Option::Some(x.unbox()),
+            Option::None(_) => Option::None(()),
+        }
+    }
+    #[inline(always)]
+    fn get(self: @Array<T>, index: usize) -> Option<Box<@T>> {
+        array_get(self, index)
+    }
+    fn at(self: @Array<T>, index: usize) -> @T {
+        array_at(self, index).unbox()
+    }
+    #[inline(always)]
+    fn len(self: @Array<T>) -> usize {
+        array_len(self)
+    }
+    #[inline(always)]
+    fn is_empty(self: @Array<T>) -> bool {
+        self.len() == 0_usize
+    }
+    #[inline(always)]
+    fn span(self: @Array<T>) -> Span<T> {
+        Span { snapshot: self }
+    }
+}
+
+impl ArrayIndex<T> of IndexView<Array<T>, usize, @T> {
+    fn index(self: @Array<T>, index: usize) -> @T {
+        array_at(self, index).unbox()
+    }
+}
+
+// Impls for common generic types
+impl ArrayDrop<T, impl TDrop: Drop<T>> of Drop<Array<T>>;
+
+// Span.
+struct Span<T> {
+    snapshot: @Array<T>
+}
+
+impl SpanCopy<T> of Copy<Span<T>>;
+impl SpanDrop<T> of Drop<Span<T>>;
+
+trait SpanTrait<T> {
+    fn pop_front(ref self: Span<T>) -> Option<@T>;
+    fn pop_back(ref self: Span<T>) -> Option<@T>;
+    fn get(self: Span<T>, index: usize) -> Option<Box<@T>>;
+    fn at(self: Span<T>, index: usize) -> @T;
+    fn slice(self: Span<T>, start: usize, length: usize) -> Span<T>;
+    fn len(self: Span<T>) -> usize;
+    fn is_empty(self: Span<T>) -> bool;
+}
+impl SpanImpl<T> of SpanTrait<T> {
+    #[inline(always)]
+    fn pop_front(ref self: Span<T>) -> Option<@T> {
+        let mut snapshot = self.snapshot;
+        let item = array_snapshot_pop_front(ref snapshot);
+        self = Span { snapshot };
+        match item {
+            Option::Some(x) => Option::Some(x.unbox()),
+            Option::None(_) => Option::None(()),
+        }
+    }
+    #[inline(always)]
+    fn pop_back(ref self: Span<T>) -> Option<@T> {
+        let mut snapshot = self.snapshot;
+        let item = array_snapshot_pop_back(ref snapshot);
+        self = Span { snapshot };
+        match item {
+            Option::Some(x) => Option::Some(x.unbox()),
+            Option::None(_) => Option::None(()),
+        }
+    }
+    #[inline(always)]
+    fn get(self: Span<T>, index: usize) -> Option<Box<@T>> {
+        array_get(self.snapshot, index)
+    }
+    #[inline(always)]
+    fn at(self: Span<T>, index: usize) -> @T {
+        array_at(self.snapshot, index).unbox()
+    }
+    #[inline(always)]
+    fn slice(self: Span<T>, start: usize, length: usize) -> Span<T> {
+        Span { snapshot: array_slice(self.snapshot, start, length).expect('Index out of bounds') }
+    }
+    #[inline(always)]
+    fn len(self: Span<T>) -> usize {
+        array_len(self.snapshot)
+    }
+    #[inline(always)]
+    fn is_empty(self: Span<T>) -> bool {
+        self.len() == 0_usize
+    }
+}
+
+impl SpanIndex<T> of IndexView<Span<T>, usize, @T> {
+    #[inline(always)]
+    fn index(self: @Span<T>, index: usize) -> @T {
+        array_at(*self.snapshot, index).unbox()
+    }
+}
+
+// TODO(spapini): Remove TDrop. It is necessary to get rid of response in case of panic.
+impl ArrayTCloneImpl<T, impl TClone: Clone<T>, impl TDrop: Drop<T>> of Clone<Array<T>> {
+    fn clone(self: @Array<T>) -> Array<T> {
+        let mut response = array_new();
+        let mut span = self.span();
+        loop {
+            match span.pop_front() {
+                Option::Some(v) => {
+                    response.append(TClone::clone(v));
+                },
+                Option::None(_) => {
+                    break ();
+                },
+            };
+        };
+        response
+    }
+}

cairo-lang-0.11.2/starkware/starknet/compiler/v1/corelib/src/box.cairo

@@ -0,0 +1,25 @@
+extern type Box<T>;
+impl BoxTCopy<T, impl TCopy: Copy<T>> of Copy<Box<T>>;
+impl BoxTDrop<T, impl TDrop: Drop<T>> of Drop<Box<T>>;
+
+// These functions are only exposed in the corelib through the trait below since calling them
+// directly with tuples panics due to auto unpacking of the tuple.
+// TODO(Gil): Expose in the core lib when the described behaviour is fixed.
+extern fn into_box<T>(value: T) -> Box<T> nopanic;
+extern fn unbox<T>(box: Box<T>) -> T nopanic;
+
+trait BoxTrait<T> {
+    fn new(value: T) -> Box<T> nopanic;
+    fn unbox(self: Box<T>) -> T nopanic;
+}
+
+impl BoxImpl<T> of BoxTrait<T> {
+    #[inline(always)]
+    fn new(value: T) -> Box<T> nopanic {
+        into_box(value)
+    }
+    #[inline(always)]
+    fn unbox(self: Box<T>) -> T nopanic {
+        unbox(self)
+    }
+}

cairo-lang-0.11.2/starkware/starknet/compiler/v1/corelib/src/clone.cairo

@@ -0,0 +1,9 @@
+trait Clone<T> {
+    fn clone(self: @T) -> T;
+}
+
+impl TCopyClone<T, impl TCopy: Copy<T>> of Clone<T> {
+    fn clone(self: @T) -> T {
+        *self
+    }
+}

cairo-lang-0.11.2/starkware/starknet/compiler/v1/corelib/src/cmp.cairo

@@ -0,0 +1,17 @@
+fn min<T, impl TPartialOrd: PartialOrd<T>, impl DropT: Drop<T>, impl CopyT: Copy<T>>(
+    a: T, b: T
+) -> T {
+    if a > b {
+        return b;
+    }
+    a
+}
+
+fn max<T, impl TPartialOrd: PartialOrd<T>, impl DropT: Drop<T>, impl CopyT: Copy<T>>(
+    a: T, b: T
+) -> T {
+    if a > b {
+        return a;
+    }
+    b
+}

cairo-lang-0.11.2/starkware/starknet/compiler/v1/corelib/src/debug.cairo

@@ -0,0 +1,96 @@
+use array::ArrayTrait;
+use traits::Into;
+use option::Option;
+
+// Usage:
+//
+// use debug::PrintTrait;
+//
+// 1.print();
+//
+// (1 == 2).print();
+//
+// get_caller_address().print();
+//
+// let mut arr = ArrayTrait::new();
+// arr.append('1234567890123456789012345678901');
+// arr.append('Sca');
+// arr.append('SomeVeryLongMessage');
+// arr.print();
+
+extern fn print(message: Array<felt252>) nopanic;
+
+fn print_felt252(message: felt252) {
+    let mut arr = ArrayTrait::new();
+    arr.append(message);
+    print(arr);
+}
+
+trait PrintTrait<T> {
+    fn print(self: T);
+}
+
+impl Felt252PrintImpl of PrintTrait<felt252> {
+    fn print(self: felt252) {
+        print_felt252(self);
+    }
+}
+
+impl BoolPrintImpl of PrintTrait<bool> {
+    fn print(self: bool) {
+        if self {
+            'true'.print();
+        } else {
+            'false'.print();
+        }
+    }
+}
+
+impl ContractAddressPrintImpl of PrintTrait<starknet::ContractAddress> {
+    fn print(self: starknet::ContractAddress) {
+        Into::<_, felt252>::into(self).print();
+    }
+}
+
+impl U8PrintImpl of PrintTrait<u8> {
+    fn print(self: u8) {
+        Into::<_, felt252>::into(self).print();
+    }
+}
+
+impl U16PrintImpl of PrintTrait<u16> {
+    fn print(self: u16) {
+        Into::<_, felt252>::into(self).print();
+    }
+}
+
+impl U32PrintImpl of PrintTrait<u32> {
+    fn print(self: u32) {
+        Into::<_, felt252>::into(self).print();
+    }
+}
+
+impl U64PrintImpl of PrintTrait<u64> {
+    fn print(self: u64) {
+        Into::<_, felt252>::into(self).print();
+    }
+}
+
+impl U128PrintImpl of PrintTrait<u128> {
+    fn print(self: u128) {
+        Into::<_, felt252>::into(self).print();
+    }
+}
+
+impl U256PrintImpl of PrintTrait<u256> {
+    fn print(self: u256) {
+        Into::<u128, felt252>::into(self.low).print();
+        Into::<u128, felt252>::into(self.high).print();
+    }
+}
+
+impl ArrayGenericPrintImpl of PrintTrait<Array<felt252>> {
+    fn print(mut self: Array<felt252>) {
+        print(self);
+    }
+}