diff --git a/Cargo.lock b/Cargo.lock
index 9bbc26f..49999ed 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,6 +2,18 @@
 # It is not intended for manual editing.
 version = 3
 
+[[package]]
+name = "ahash"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77c3a9648d43b9cd48db467b3f87fdd6e146bcc88ab0180006cef2179fe11d01"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "1.0.4"
@@ -11,6 +23,12 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "allocator-api2"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0942ffc6dcaadf03badf6e6a2d0228460359d5e34b57ccdc720b7382dfbd5ec5"
+
 [[package]]
 name = "anstream"
 version = "0.5.0"
@@ -65,6 +83,70 @@ version = "1.0.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6"
 
+[[package]]
+name = "ark-ff"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec847af850f44ad29048935519032c33da8aa03340876d351dfab5660d2966ba"
+dependencies = [
+ "ark-ff-asm",
+ "ark-ff-macros",
+ "ark-serialize",
+ "ark-std",
+ "derivative",
+ "digest",
+ "itertools 0.10.5",
+ "num-bigint",
+ "num-traits 0.2.16",
+ "paste",
+ "rustc_version",
+ "zeroize",
+]
+
+[[package]]
+name = "ark-ff-asm"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ed4aa4fe255d0bc6d79373f7e31d2ea147bcf486cba1be5ba7ea85abdb92348"
+dependencies = [
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "ark-ff-macros"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7abe79b0e4288889c4574159ab790824d0033b9fdcb2a112a3182fac2e514565"
+dependencies = [
+ "num-bigint",
+ "num-traits 0.2.16",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "ark-serialize"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb7b85a02b83d2f22f89bd5cac66c9c89474240cb6207cb1efc16d098e822a5"
+dependencies = [
+ "ark-std",
+ "digest",
+ "num-bigint",
+]
+
+[[package]]
+name = "ark-std"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94893f1e0c6eeab764ade8dc4c0db24caf4fe7cbbaafc0eba0a9030f447b5185"
+dependencies = [
+ "num-traits 0.2.16",
+ "rand",
+]
+
 [[package]]
 name = "arrayvec"
 version = "0.7.4"
@@ -150,17 +232,29 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "bumpalo"
+version = "3.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec"
+
 [[package]]
 name = "byte-slice-cast"
 version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3ac9f8b63eca6fd385229b3675f6cc0dc5c8a5c8a54a59d4f52ffd670d87b0c"
 
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
 [[package]]
 name = "cairo-felt"
-version = "0.8.7"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5972097b8800ca5dffb458040e74c724a2ac4fa4b5b480b50f5b96c7e67d6427"
+checksum = "ae932292b9ba497a4e892b56aa4e0c6f329a455180fdbdc132700dfe68d9b153"
 dependencies = [
  "lazy_static",
  "num-bigint",
@@ -171,24 +265,22 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-casm"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "cairo-lang-utils",
+ "hashbrown 0.14.3",
  "indoc",
  "num-bigint",
  "num-traits 0.2.16",
  "parity-scale-codec",
- "parity-scale-codec-derive",
- "schemars",
  "serde",
- "thiserror",
 ]
 
 [[package]]
 name = "cairo-lang-compiler"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "anyhow",
  "cairo-lang-defs",
@@ -196,32 +288,28 @@ dependencies = [
  "cairo-lang-filesystem",
  "cairo-lang-lowering",
  "cairo-lang-parser",
- "cairo-lang-plugins",
  "cairo-lang-project",
  "cairo-lang-semantic",
  "cairo-lang-sierra",
  "cairo-lang-sierra-generator",
  "cairo-lang-syntax",
  "cairo-lang-utils",
- "itertools 0.11.0",
- "log",
  "salsa",
- "smol_str",
  "thiserror",
 ]
 
 [[package]]
 name = "cairo-lang-debug"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "cairo-lang-utils",
 ]
 
 [[package]]
 name = "cairo-lang-defs"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "cairo-lang-debug",
  "cairo-lang-diagnostics",
@@ -229,7 +317,6 @@ dependencies = [
  "cairo-lang-parser",
  "cairo-lang-syntax",
  "cairo-lang-utils",
- "indexmap 2.0.0",
  "itertools 0.11.0",
  "salsa",
  "smol_str",
@@ -237,31 +324,28 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-diagnostics"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "cairo-lang-debug",
  "cairo-lang-filesystem",
  "cairo-lang-utils",
  "itertools 0.11.0",
- "salsa",
 ]
 
 [[package]]
 name = "cairo-lang-eq-solver"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "cairo-lang-utils",
  "good_lp",
- "indexmap 2.0.0",
- "itertools 0.11.0",
 ]
 
 [[package]]
 name = "cairo-lang-filesystem"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "cairo-lang-debug",
  "cairo-lang-utils",
@@ -273,8 +357,8 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-lowering"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "cairo-lang-debug",
  "cairo-lang-defs",
@@ -286,7 +370,6 @@ dependencies = [
  "cairo-lang-syntax",
  "cairo-lang-utils",
  "id-arena",
- "indexmap 2.0.0",
  "itertools 0.11.0",
  "log",
  "num-bigint",
@@ -298,8 +381,8 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-parser"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "cairo-lang-diagnostics",
  "cairo-lang-filesystem",
@@ -308,7 +391,6 @@ dependencies = [
  "cairo-lang-utils",
  "colored",
  "itertools 0.11.0",
- "log",
  "num-bigint",
  "num-traits 0.2.16",
  "salsa",
@@ -318,8 +400,8 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-plugins"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "cairo-lang-defs",
  "cairo-lang-diagnostics",
@@ -330,25 +412,24 @@ dependencies = [
  "indent",
  "indoc",
  "itertools 0.11.0",
- "num-bigint",
  "salsa",
  "smol_str",
 ]
 
 [[package]]
 name = "cairo-lang-proc-macros"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "cairo-lang-debug",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.39",
 ]
 
 [[package]]
 name = "cairo-lang-project"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "cairo-lang-filesystem",
  "cairo-lang-utils",
@@ -360,8 +441,8 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-semantic"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "cairo-lang-debug",
  "cairo-lang-defs",
@@ -373,8 +454,8 @@ dependencies = [
  "cairo-lang-syntax",
  "cairo-lang-utils",
  "id-arena",
+ "indoc",
  "itertools 0.11.0",
- "log",
  "num-bigint",
  "num-traits 0.2.16",
  "once_cell",
@@ -384,9 +465,11 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-sierra"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
+ "anyhow",
+ "cairo-felt",
  "cairo-lang-utils",
  "const-fnv1a-hash",
  "convert_case",
@@ -399,6 +482,7 @@ dependencies = [
  "regex",
  "salsa",
  "serde",
+ "serde_json",
  "sha3",
  "smol_str",
  "thiserror",
@@ -406,34 +490,36 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-sierra-ap-change"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "cairo-lang-eq-solver",
  "cairo-lang-sierra",
  "cairo-lang-sierra-type-size",
  "cairo-lang-utils",
  "itertools 0.11.0",
+ "num-traits 0.2.16",
  "thiserror",
 ]
 
 [[package]]
 name = "cairo-lang-sierra-gas"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "cairo-lang-eq-solver",
  "cairo-lang-sierra",
  "cairo-lang-sierra-type-size",
  "cairo-lang-utils",
  "itertools 0.11.0",
+ "num-traits 0.2.16",
  "thiserror",
 ]
 
 [[package]]
 name = "cairo-lang-sierra-generator"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "cairo-lang-debug",
  "cairo-lang-defs",
@@ -441,14 +527,10 @@ dependencies = [
  "cairo-lang-filesystem",
  "cairo-lang-lowering",
  "cairo-lang-parser",
- "cairo-lang-plugins",
- "cairo-lang-proc-macros",
  "cairo-lang-semantic",
  "cairo-lang-sierra",
  "cairo-lang-syntax",
  "cairo-lang-utils",
- "id-arena",
- "indexmap 2.0.0",
  "itertools 0.11.0",
  "num-bigint",
  "once_cell",
@@ -458,8 +540,8 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-sierra-to-casm"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "assert_matches",
  "cairo-felt",
@@ -471,7 +553,6 @@ dependencies = [
  "cairo-lang-utils",
  "indoc",
  "itertools 0.11.0",
- "log",
  "num-bigint",
  "num-traits 0.2.16",
  "thiserror",
@@ -479,8 +560,8 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-sierra-type-size"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "cairo-lang-sierra",
  "cairo-lang-utils",
@@ -488,8 +569,8 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-starknet"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "anyhow",
  "cairo-felt",
@@ -499,22 +580,17 @@ dependencies = [
  "cairo-lang-diagnostics",
  "cairo-lang-filesystem",
  "cairo-lang-lowering",
- "cairo-lang-parser",
- "cairo-lang-plugins",
  "cairo-lang-semantic",
  "cairo-lang-sierra",
- "cairo-lang-sierra-ap-change",
- "cairo-lang-sierra-gas",
  "cairo-lang-sierra-generator",
  "cairo-lang-sierra-to-casm",
  "cairo-lang-syntax",
  "cairo-lang-utils",
+ "const_format",
  "convert_case",
- "genco",
  "indent",
  "indoc",
  "itertools 0.11.0",
- "log",
  "num-bigint",
  "num-integer",
  "num-traits 0.2.16",
@@ -523,13 +599,14 @@ dependencies = [
  "serde_json",
  "sha3",
  "smol_str",
+ "starknet-crypto",
  "thiserror",
 ]
 
 [[package]]
 name = "cairo-lang-syntax"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "cairo-lang-debug",
  "cairo-lang-filesystem",
@@ -538,14 +615,13 @@ dependencies = [
  "num-traits 0.2.16",
  "salsa",
  "smol_str",
- "thiserror",
  "unescaper",
 ]
 
 [[package]]
 name = "cairo-lang-syntax-codegen"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
  "genco",
  "xshell",
@@ -553,15 +629,14 @@ dependencies = [
 
 [[package]]
 name = "cairo-lang-utils"
-version = "2.2.0"
-source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.2.0#ad5570f0f25dbbffd9daedf02df140ff9e7291e4"
+version = "2.5.0"
+source = "git+https://github.com/starkware-libs/cairo.git?tag=v2.5.0#1a4ccb01f6fb0a74bfc23238ca1088fe2659d087"
 dependencies = [
- "indexmap 2.0.0",
+ "hashbrown 0.14.3",
+ "indexmap 2.1.0",
  "itertools 0.11.0",
  "num-bigint",
- "num-integer",
  "num-traits 0.2.16",
- "parity-scale-codec",
  "schemars",
  "serde",
 ]
@@ -584,12 +659,14 @@ dependencies = [
  "cairo-lang-syntax",
  "cairo-lang-utils",
  "clap",
+ "fxhash",
  "graphviz-rust",
  "insta",
  "num-bigint",
  "num-integer",
  "num-traits 0.2.16",
  "once_cell",
+ "rayon",
  "serde_json",
  "smol_str",
  "termcolor",
@@ -643,7 +720,7 @@ dependencies = [
  "heck 0.4.1",
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.39",
 ]
 
 [[package]]
@@ -687,6 +764,26 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32b13ea120a812beba79e34316b3942a857c86ec1593cb34f27bb28272ce2cca"
 
+[[package]]
+name = "const_format"
+version = "0.2.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3a214c7af3d04997541b18d432afaff4c455e79e2029079647e72fc2bd27673"
+dependencies = [
+ "const_format_proc_macros",
+]
+
+[[package]]
+name = "const_format_proc_macros"
+version = "0.2.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7f6ff08fd20f4f299298a28e2dfa8a8ba1036e6cd2460ac1de7b425d76f2500"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
 [[package]]
 name = "convert_case"
 version = "0.6.0"
@@ -705,11 +802,33 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fca89a0e215bab21874660c67903c5f143333cab1da83d041c7ded6053774751"
+dependencies = [
+ "cfg-if",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e3681d554572a651dda4186cd47240627c3d0114d45a95f6ad27f2f22e7548d"
+dependencies = [
+ "autocfg",
+ "cfg-if",
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.16"
+version = "0.8.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a22b2d63d4d1dc0b7f1b6b2747dd0088008a9be28b6ddf0b1e7d335e3037294"
+checksum = "c3a430a770ebd84726f584a90ee7f020d28db52c6d02138900f22341f866d39c"
 dependencies = [
  "cfg-if",
 ]
@@ -720,6 +839,17 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
 
+[[package]]
+name = "crypto-bigint"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
+dependencies = [
+ "generic-array",
+ "subtle",
+ "zeroize",
+]
+
 [[package]]
 name = "crypto-common"
 version = "0.1.6"
@@ -755,6 +885,7 @@ checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
  "block-buffer",
  "crypto-common",
+ "subtle",
 ]
 
 [[package]]
@@ -871,11 +1002,20 @@ version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
+[[package]]
+name = "fxhash"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
+dependencies = [
+ "byteorder",
+]
+
 [[package]]
 name = "genco"
-version = "0.17.5"
+version = "0.17.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6973ce8518068a71d404f428f6a5b563088545546a6bd8f9c0a7f2608149bc8a"
+checksum = "98d7af598790738fee616426e669360fa361273b1b9c9b7f30c92fa627605cad"
 dependencies = [
  "genco-macros",
  "relative-path",
@@ -884,13 +1024,13 @@ dependencies = [
 
 [[package]]
 name = "genco-macros"
-version = "0.17.5"
+version = "0.17.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c2c778cf01917d0fbed53900259d6604a421fab4916a2e738856ead9f1d926a"
+checksum = "d4cf186fea4af17825116f72932fe52cce9a13bae39ff63b4dc0cfdb3fb4bde1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.39",
 ]
 
 [[package]]
@@ -910,8 +1050,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
  "wasi",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -929,9 +1071,9 @@ dependencies = [
 
 [[package]]
 name = "good_lp"
-version = "1.5.0"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa7f3b0e0de4e671b6ffc1274b153a9394cb58bf04ee67505b0cb9915513115f"
+checksum = "fa124423ded10046a849fa0ae9747c541895557f1af177e0890b09879e7e9e7d"
 dependencies = [
  "fnv",
  "minilp",
@@ -939,9 +1081,9 @@ dependencies = [
 
 [[package]]
 name = "graphviz-rust"
-version = "0.6.6"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27dafd1ac303e0dfb347a3861d9ac440859bab26ec2f534bbceb262ea492a1e0"
+checksum = "f3f7a4f4b8db9d330c49744d0f98ce7c9a37e3e32a0d247a90338119b2040184"
 dependencies = [
  "dot-generator",
  "dot-structures",
@@ -961,9 +1103,14 @@ checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 
 [[package]]
 name = "hashbrown"
-version = "0.14.0"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c6201b9ff9fd90a5a3bac2e56a830d0caa509576f0e503818ee82c181b3437a"
+checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
+dependencies = [
+ "ahash",
+ "allocator-api2",
+ "serde",
+]
 
 [[package]]
 name = "heck"
@@ -986,6 +1133,21 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "443144c8cdadd93ebf52ddb4056d257f5b52c04d3c804e657d19eb73fc33668b"
 
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
 [[package]]
 name = "id-arena"
 version = "2.2.1"
@@ -1022,20 +1184,20 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.0.0"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5477fe2230a79769d8dc68e0eabf5437907c0457a5614a9e8dddb67f65eb65d"
+checksum = "d530e1a18b1cb4c484e6e34556a0d948706958449fca0cab753d649f2bce3d1f"
 dependencies = [
  "equivalent",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.3",
  "serde",
 ]
 
 [[package]]
 name = "indoc"
-version = "2.0.3"
+version = "2.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c785eefb63ebd0e33416dfcb8d6da0bf27ce752843a45632a67bf10d4d4b5c4"
+checksum = "1e186cfbae8084e513daff4240b4797e342f988cecda4fb6c939150f96315fd8"
 
 [[package]]
 name = "insta"
@@ -1118,6 +1280,15 @@ version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38"
 
+[[package]]
+name = "js-sys"
+version = "0.3.66"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cee9c64da59eae3b50095c18d3e74f8b73c0b86d2792824ff01bbce68ba229ca"
+dependencies = [
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "keccak"
 version = "0.1.4"
@@ -1310,22 +1481,23 @@ checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
 
 [[package]]
 name = "parity-scale-codec"
-version = "3.6.4"
+version = "3.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8e946cc0cc711189c0b0249fb8b599cbeeab9784d83c415719368bb8d4ac64"
+checksum = "0dec8a8073036902368c2cdc0387e85ff9a37054d7e7c98e592145e0c92cd4fb"
 dependencies = [
  "arrayvec",
  "bitvec",
  "byte-slice-cast",
  "impl-trait-for-tuples",
+ "parity-scale-codec-derive",
  "serde",
 ]
 
 [[package]]
 name = "parity-scale-codec-derive"
-version = "3.6.4"
+version = "3.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a296c3079b5fefbc499e1de58dc26c09b1b9a5952d26694ee89f04a43ebbb3e"
+checksum = "312270ee71e1cd70289dacf597cab7b207aa107d2f28191c2ae45b2ece18a260"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
@@ -1381,6 +1553,12 @@ dependencies = [
  "windows-targets 0.48.5",
 ]
 
+[[package]]
+name = "paste"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c"
+
 [[package]]
 name = "path-clean"
 version = "1.0.1"
@@ -1417,7 +1595,7 @@ dependencies = [
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.39",
 ]
 
 [[package]]
@@ -1438,7 +1616,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1d3afd2628e69da2be385eb6f2fd57c8ac7977ceeff6dc166ff1657b0e386a9"
 dependencies = [
  "fixedbitset",
- "indexmap 2.0.0",
+ "indexmap 2.1.0",
 ]
 
 [[package]]
@@ -1475,14 +1653,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919"
 dependencies = [
  "once_cell",
- "toml_edit",
+ "toml_edit 0.19.15",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.66"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9"
+checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da"
 dependencies = [
  "unicode-ident",
 ]
@@ -1538,6 +1716,26 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
 
+[[package]]
+name = "rayon"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c27db03db7734835b3f53954b534c91069375ce6ccaa2e065441e07d9b6cdb1"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ce3fb6ad83f861aac485e76e1985cd109d9a3713802152be56c3b1f0e0658ed"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.2.16"
@@ -1602,12 +1800,31 @@ version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c707298afce11da2efef2f600116fa93ffa7a032b5d7b628aa17711ec81383ca"
 
+[[package]]
+name = "rfc6979"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
+dependencies = [
+ "hmac",
+ "subtle",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rustc_version"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+dependencies = [
+ "semver",
+]
+
 [[package]]
 name = "rustix"
 version = "0.38.9"
@@ -1673,9 +1890,9 @@ dependencies = [
 
 [[package]]
 name = "schemars"
-version = "0.8.12"
+version = "0.8.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02c613288622e5f0c3fdc5dbd4db1c5fbe752746b1d1a56a0630b78fd00de44f"
+checksum = "45a28f4c49489add4ce10783f7911893516f15afe45d015608d41faca6bc4d29"
 dependencies = [
  "dyn-clone",
  "indexmap 1.9.3",
@@ -1686,9 +1903,9 @@ dependencies = [
 
 [[package]]
 name = "schemars_derive"
-version = "0.8.12"
+version = "0.8.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "109da1e6b197438deb6db99952990c7f959572794b80ff93707d55a232545e7c"
+checksum = "c767fd6fa65d9ccf9cf026122c1b555f2ef9a4f0cea69da4d7dbc3e258d30967"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1702,24 +1919,30 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
+[[package]]
+name = "semver"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97ed7a9823b74f99c7742f5336af7be5ecd3eeafcb1507d1fa93347b1d589b0"
+
 [[package]]
 name = "serde"
-version = "1.0.188"
+version = "1.0.192"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf9e0fcba69a370eed61bcf2b728575f726b50b55cba78064753d708ddc7549e"
+checksum = "bca2a08484b285dcb282d0f67b26cadc0df8b19f8c12502c13d966bf9482f001"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.188"
+version = "1.0.192"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2"
+checksum = "d6c7207fbec9faa48073f3e3074cbe553af6ea512d7c21ba46e434e70ea9fbc1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.39",
 ]
 
 [[package]]
@@ -1746,9 +1969,9 @@ dependencies = [
 
 [[package]]
 name = "serde_spanned"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96426c9936fd7a0124915f9185ea1d20aa9445cc9821142f0a73bc9207a2e186"
+checksum = "12022b835073e5b11e90a14f86838ceb1c8fb0325b72416845c487ac0fa95e80"
 dependencies = [
  "serde",
 ]
@@ -1818,6 +2041,58 @@ dependencies = [
  "num-traits 0.1.43",
 ]
 
+[[package]]
+name = "starknet-crypto"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33c03f5ac70f9b067f48db7d2d70bdf18ee0f731e8192b6cfa679136becfcdb0"
+dependencies = [
+ "crypto-bigint",
+ "hex",
+ "hmac",
+ "num-bigint",
+ "num-integer",
+ "num-traits 0.2.16",
+ "rfc6979",
+ "sha2",
+ "starknet-crypto-codegen",
+ "starknet-curve",
+ "starknet-ff",
+ "zeroize",
+]
+
+[[package]]
+name = "starknet-crypto-codegen"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af6527b845423542c8a16e060ea1bc43f67229848e7cd4c4d80be994a84220ce"
+dependencies = [
+ "starknet-curve",
+ "starknet-ff",
+ "syn 2.0.39",
+]
+
+[[package]]
+name = "starknet-curve"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a68a0d87ae56572abf83ddbfd44259a7c90dbeeee1629a1ffe223e7f9a8f3052"
+dependencies = [
+ "starknet-ff",
+]
+
+[[package]]
+name = "starknet-ff"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "067419451efdea1ee968df8438369960c167e0e905c05b84afd074f50e1d6f3d"
+dependencies = [
+ "ark-ff",
+ "crypto-bigint",
+ "getrandom",
+ "hex",
+]
+
 [[package]]
 name = "string_cache"
 version = "0.8.7"
@@ -1837,6 +2112,12 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
+[[package]]
+name = "subtle"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
+
 [[package]]
 name = "syn"
 version = "1.0.109"
@@ -1850,9 +2131,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.29"
+version = "2.0.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c324c494eba9d92503e6f1ef2e6df781e78f6a7705a0202d9801b198807d518a"
+checksum = "23e78b90f2fcf45d3e842032ce32e3f2d1545ba6636271dcbf24fa306d87be7a"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1900,22 +2181,22 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.47"
+version = "1.0.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97a802ec30afc17eee47b2855fc72e0c4cd62be9b4efe6591edde0ec5bd68d8f"
+checksum = "f9a7210f5c9a7156bb50aa36aed4c95afb51df0df00713949448cf9e97d382d2"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.47"
+version = "1.0.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bb623b56e39ab7dcd4b1b98bb6c8f8d907ed255b18de254088016b27a8ee19b"
+checksum = "266b2e40bc00e5a6c09c3584011e08b06f123c00362c92b975ba9843aaaa14b8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.39",
 ]
 
 [[package]]
@@ -1929,32 +2210,43 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.7.6"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c17e963a819c331dcacd7ab957d80bc2b9a9c1e71c804826d2f283dd65306542"
+checksum = "a1a195ec8c9da26928f773888e0742ca3ca1040c6cd859c919c9f59c1954ab35"
 dependencies = [
  "serde",
  "serde_spanned",
  "toml_datetime",
- "toml_edit",
+ "toml_edit 0.21.0",
 ]
 
 [[package]]
 name = "toml_datetime"
-version = "0.6.3"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cda73e2f1397b1262d6dfdcef8aafae14d1de7748d66822d3bfeeb6d03e5e4b"
+checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "toml_edit"
-version = "0.19.14"
+version = "0.19.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8123f27e969974a3dfba720fdb560be359f57b44302d280ba72e76a74480e8a"
+checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
 dependencies = [
- "indexmap 2.0.0",
+ "indexmap 2.1.0",
+ "toml_datetime",
+ "winnow",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d34d383cd00a163b4a5b85053df514d45bc330f6de7737edfe0a93311d1eaa03"
+dependencies = [
+ "indexmap 2.1.0",
  "serde",
  "serde_spanned",
  "toml_datetime",
@@ -2028,6 +2320,60 @@ version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ed0d4f68a3015cc185aff4db9506a015f4b96f95303897bfa23f846db54064e"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b56f625e64f3a1084ded111c4d5f477df9f8c92df113852fa5a374dbda78826"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0162dbf37223cd2afce98f3d0785506dcb8d266223983e4b5b525859e6e182b2"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0eb82fcb7930ae6219a7ecfd55b217f5f0893484b7a13022ebb2b2bf20b5283"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ab9b36309365056cd639da3134bf87fa8f3d86008abf99e612384a6eecd459f"
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -2232,3 +2578,43 @@ checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
 dependencies = [
  "linked-hash-map",
 ]
+
+[[package]]
+name = "zerocopy"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d"
+dependencies = [
+ "zeroize_derive",
+]
+
+[[package]]
+name = "zeroize_derive"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+]
diff --git a/Cargo.toml b/Cargo.toml
index 5547afd..3761435 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,21 +16,24 @@ once_cell =  "1.17"
 smol_str = "0.2"
 num-integer = "0.1"
 termcolor = "1.2"
-graphviz-rust = "0.6.2"
-cairo-felt = "0.8.7"
+graphviz-rust = "0.7.0"
+cairo-felt = "0.9.1"
 thiserror = "1.0.47"
+rayon = "1.8"
+fxhash = "0.2.1"
+
+cairo-lang-compiler = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.5.0" }
+cairo-lang-defs = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.5.0" }
+cairo-lang-plugins = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.5.0" }
+cairo-lang-starknet = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.5.0" }
+cairo-lang-filesystem = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.5.0" }
+cairo-lang-parser = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.5.0" }
+cairo-lang-syntax = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.5.0" }
+cairo-lang-semantic = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.5.0" }
+cairo-lang-utils = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.5.0" }
+cairo-lang-sierra-generator = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.5.0" }
+cairo-lang-sierra = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.5.0" }
 
-cairo-lang-compiler = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.2.0" }
-cairo-lang-defs = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.2.0" }
-cairo-lang-plugins = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.2.0" }
-cairo-lang-starknet = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.2.0" }
-cairo-lang-filesystem = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.2.0" }
-cairo-lang-parser = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.2.0" }
-cairo-lang-syntax = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.2.0" }
-cairo-lang-semantic = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.2.0" }
-cairo-lang-utils = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.2.0" }
-cairo-lang-sierra-generator = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.2.0" }
-cairo-lang-sierra = { git = "https://github.com/starkware-libs/cairo.git", tag = "v2.2.0" }
 
 [dev-dependencies]
 insta = { version = "1.30", features = ["glob"] }
diff --git a/corelib/Scarb.toml b/corelib/Scarb.toml
index dabde0b..9bdbd33 100644
--- a/corelib/Scarb.toml
+++ b/corelib/Scarb.toml
@@ -1,6 +1,7 @@
 [package]
 name = "core"
-version = "2.2.0"
+version = "2.5.0"
+edition = "2023_11"
 
 # NOTE: This is non-public, unstable Scarb's field, which instructs resolver that this package does not
 #   depend on `core`, which is only true for this particular package. Nobody else should use it.
diff --git a/corelib/cairo_project.toml b/corelib/cairo_project.toml
index db46c53..40985b4 100644
--- a/corelib/cairo_project.toml
+++ b/corelib/cairo_project.toml
@@ -1,2 +1,8 @@
 [crate_roots]
 core = "src"
+
+[config.global]
+edition = "2023_11"
+
+[config.global.experimental_features]
+negative_impls = true
diff --git a/corelib/src/array.cairo b/corelib/src/array.cairo
index 0b1a2ed..30164a4 100644
--- a/corelib/src/array.cairo
+++ b/corelib/src/array.cairo
@@ -1,12 +1,13 @@
-use traits::IndexView;
+use core::traits::IndexView;
 
-use box::BoxTrait;
-use gas::withdraw_gas;
-use option::OptionTrait;
-use serde::Serde;
+use core::box::BoxTrait;
+use core::gas::withdraw_gas;
+use core::option::OptionTrait;
+use core::serde::Serde;
+use core::metaprogramming::TypeEqual;
 
 #[derive(Drop)]
-extern type Array<T>;
+pub extern type Array<T>;
 
 extern fn array_new<T>() -> Array<T> nopanic;
 extern fn array_append<T>(ref arr: Array<T>, value: T) nopanic;
@@ -24,15 +25,24 @@ extern fn array_slice<T>(
 extern fn array_len<T>(arr: @Array<T>) -> usize nopanic;
 
 #[generate_trait]
-impl ArrayImpl<T> of ArrayTrait<T> {
+pub impl ArrayImpl<T> of ArrayTrait<T> {
     #[inline(always)]
     fn new() -> Array<T> {
         array_new()
     }
     #[inline(always)]
-    fn append(ref self: Array<T>, value: T) {
+    fn append(ref self: Array<T>, value: T) nopanic {
         array_append(ref self, value)
     }
+    fn append_span<+Clone<T>, +Drop<T>>(ref self: Array<T>, mut span: Span<T>) {
+        match span.pop_front() {
+            Option::Some(current) => {
+                self.append(current.clone());
+                self.append_span(span);
+            },
+            Option::None => {}
+        };
+    }
     #[inline(always)]
     fn pop_front(ref self: Array<T>) -> Option<T> nopanic {
         match array_pop_front(ref self) {
@@ -55,14 +65,21 @@ impl ArrayImpl<T> of ArrayTrait<T> {
         array_at(self, index).unbox()
     }
     #[inline(always)]
+    #[must_use]
     fn len(self: @Array<T>) -> usize {
         array_len(self)
     }
     #[inline(always)]
+    #[must_use]
     fn is_empty(self: @Array<T>) -> bool {
-        self.len() == 0_usize
+        let mut snapshot = self;
+        match array_snapshot_pop_front(ref snapshot) {
+            Option::Some(_) => false,
+            Option::None => true,
+        }
     }
     #[inline(always)]
+    #[must_use]
     fn span(self: @Array<T>) -> Span<T> {
         Span { snapshot: self }
     }
@@ -81,7 +98,7 @@ impl ArrayIndex<T> of IndexView<Array<T>, usize, @T> {
     }
 }
 
-impl ArraySerde<T, impl TSerde: Serde<T>, impl TDrop: Drop<T>> of Serde<Array<T>> {
+impl ArraySerde<T, +Serde<T>, +Drop<T>> of Serde<Array<T>> {
     fn serialize(self: @Array<T>, ref output: Array<felt252>) {
         self.len().serialize(ref output);
         serialize_array_helper(self.span(), ref output);
@@ -93,9 +110,7 @@ impl ArraySerde<T, impl TSerde: Serde<T>, impl TDrop: Drop<T>> of Serde<Array<T>
     }
 }
 
-fn serialize_array_helper<T, impl TSerde: Serde<T>, impl TDrop: Drop<T>>(
-    mut input: Span<T>, ref output: Array<felt252>
-) {
+fn serialize_array_helper<T, +Serde<T>, +Drop<T>>(mut input: Span<T>, ref output: Array<felt252>) {
     match input.pop_front() {
         Option::Some(value) => {
             value.serialize(ref output);
@@ -105,25 +120,39 @@ fn serialize_array_helper<T, impl TSerde: Serde<T>, impl TDrop: Drop<T>>(
     }
 }
 
-fn deserialize_array_helper<T, impl TSerde: Serde<T>, impl TDrop: Drop<T>>(
+fn deserialize_array_helper<T, +Serde<T>, +Drop<T>>(
     ref serialized: Span<felt252>, mut curr_output: Array<T>, remaining: felt252
 ) -> Option<Array<T>> {
     if remaining == 0 {
         return Option::Some(curr_output);
     }
-    curr_output.append(TSerde::deserialize(ref serialized)?);
+    curr_output.append(Serde::deserialize(ref serialized)?);
     deserialize_array_helper(ref serialized, curr_output, remaining - 1)
 }
 
 // Span.
-struct Span<T> {
+pub struct Span<T> {
     snapshot: @Array<T>
 }
 
 impl SpanCopy<T> of Copy<Span<T>>;
 impl SpanDrop<T> of Drop<Span<T>>;
 
-impl SpanSerde<T, impl TSerde: Serde<T>, impl TDrop: Drop<T>> of Serde<Span<T>> {
+impl SpanFelt252Serde of Serde<Span<felt252>> {
+    fn serialize(self: @Span<felt252>, ref output: Array<felt252>) {
+        (*self).len().serialize(ref output);
+        serialize_array_helper(*self, ref output)
+    }
+
+    fn deserialize(ref serialized: Span<felt252>) -> Option<Span<felt252>> {
+        let length: u32 = (*serialized.pop_front()?).try_into()?;
+        let res = serialized.slice(0, length);
+        serialized = serialized.slice(length, serialized.len() - length);
+        Option::Some(res)
+    }
+}
+
+impl SpanSerde<T, +Serde<T>, +Drop<T>, -TypeEqual<felt252, T>> of Serde<Span<T>> {
     fn serialize(self: @Span<T>, ref output: Array<felt252>) {
         (*self).len().serialize(ref output);
         serialize_array_helper(*self, ref output)
@@ -137,7 +166,7 @@ impl SpanSerde<T, impl TSerde: Serde<T>, impl TDrop: Drop<T>> of Serde<Span<T>>
 }
 
 #[generate_trait]
-impl SpanImpl<T> of SpanTrait<T> {
+pub impl SpanImpl<T> of SpanTrait<T> {
     #[inline(always)]
     fn pop_front(ref self: Span<T>) -> Option<@T> {
         let mut snapshot = self.snapshot;
@@ -171,16 +200,22 @@ impl SpanImpl<T> of SpanTrait<T> {
         Span { snapshot: array_slice(self.snapshot, start, length).expect('Index out of bounds') }
     }
     #[inline(always)]
+    #[must_use]
     fn len(self: Span<T>) -> usize {
         array_len(self.snapshot)
     }
     #[inline(always)]
+    #[must_use]
     fn is_empty(self: Span<T>) -> bool {
-        self.len() == 0_usize
+        let mut snapshot = self.snapshot;
+        match array_snapshot_pop_front(ref snapshot) {
+            Option::Some(_) => false,
+            Option::None => true,
+        }
     }
 }
 
-impl SpanIndex<T> of IndexView<Span<T>, usize, @T> {
+pub 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()
@@ -188,25 +223,21 @@ impl SpanIndex<T> of IndexView<Span<T>, usize, @T> {
 }
 
 // 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>> {
+impl ArrayTCloneImpl<T, +Clone<T>, +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 ();
-                },
+                Option::Some(v) => { response.append(v.clone()); },
+                Option::None => { break (); },
             };
         };
         response
     }
 }
 
-impl ArrayPartialEq<T, impl PartialEqImpl: PartialEq<T>> of PartialEq<Array<T>> {
+impl ArrayPartialEq<T, +PartialEq<T>> of PartialEq<Array<T>> {
     fn eq(lhs: @Array<T>, rhs: @Array<T>) -> bool {
         lhs.span() == rhs.span()
     }
@@ -215,7 +246,7 @@ impl ArrayPartialEq<T, impl PartialEqImpl: PartialEq<T>> of PartialEq<Array<T>>
     }
 }
 
-impl SpanPartialEq<T, impl PartialEqImpl: PartialEq<T>> of PartialEq<Span<T>> {
+impl SpanPartialEq<T, +PartialEq<T>> of PartialEq<Span<T>> {
     fn eq(lhs: @Span<T>, rhs: @Span<T>) -> bool {
         if (*lhs).len() != (*rhs).len() {
             return false;
@@ -229,9 +260,7 @@ impl SpanPartialEq<T, impl PartialEqImpl: PartialEq<T>> of PartialEq<Span<T>> {
                         break false;
                     }
                 },
-                Option::None => {
-                    break true;
-                },
+                Option::None => { break true; },
             };
         }
     }
diff --git a/corelib/src/boolean.cairo b/corelib/src/boolean.cairo
new file mode 100644
index 0000000..f51efba
--- /dev/null
+++ b/corelib/src/boolean.cairo
@@ -0,0 +1,19 @@
+#[generate_trait]
+pub impl BoolImpl<T, +Drop<T>> of BoolTrait<T> {
+    /// Returns `Some(t)` if the `bool` is `true`, or `None` otherwise.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// assert(false.then_some(0) == Option::None);
+    /// assert(true.then_some(0) == Option::Some(0));
+    /// ```
+    #[inline(always)]
+    fn then_some(self: bool, t: T) -> Option<T> nopanic {
+        if self {
+            Option::Some(t)
+        } else {
+            Option::None
+        }
+    }
+}
diff --git a/corelib/src/box.cairo b/corelib/src/box.cairo
index 8321096..706bdaa 100644
--- a/corelib/src/box.cairo
+++ b/corelib/src/box.cairo
@@ -1,20 +1,34 @@
 #[derive(Copy, Drop)]
-extern type Box<T>;
+pub extern type 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;
+extern fn box_forward_snapshot<T>(value: @Box<T>) -> Box<@T> nopanic;
 
 #[generate_trait]
-impl BoxImpl<T> of BoxTrait<T> {
+pub impl BoxImpl<T> of BoxTrait<T> {
     #[inline(always)]
+    #[must_use]
     fn new(value: T) -> Box<T> nopanic {
         into_box(value)
     }
     #[inline(always)]
+    #[must_use]
     fn unbox(self: Box<T>) -> T nopanic {
         unbox(self)
     }
+    #[must_use]
+    fn as_snapshot(self: @Box<T>) -> Box<@T> nopanic {
+        box_forward_snapshot(self)
+    }
+}
+
+impl BoxDebug<T, impl TDebug: core::fmt::Debug<T>> of core::fmt::Debug<Box<T>> {
+    fn fmt(self: @Box<T>, ref f: core::fmt::Formatter) -> Result<(), core::fmt::Error> {
+        write!(f, "&")?;
+        TDebug::fmt(self.as_snapshot().unbox(), ref f)
+    }
 }
diff --git a/corelib/src/byte_array.cairo b/corelib/src/byte_array.cairo
index 676f47a..ce6df4c 100644
--- a/corelib/src/byte_array.cairo
+++ b/corelib/src/byte_array.cairo
@@ -1,42 +1,44 @@
-use array::{ArrayTrait, SpanTrait};
-use bytes_31::{
+use core::array::{ArrayTrait, SpanTrait};
+use core::bytes_31::{
     BYTES_IN_BYTES31, Bytes31Trait, one_shift_left_bytes_felt252, one_shift_left_bytes_u128,
     POW_2_128, POW_2_8, U128IntoBytes31, U8IntoBytes31
 };
-use clone::Clone;
-use cmp::min;
-use integer::{u128_safe_divmod, U32TryIntoNonZero};
-use option::OptionTrait;
-use traits::{Into, TryInto};
-use zeroable::NonZeroIntoImpl;
-
+use core::clone::Clone;
+use core::cmp::min;
+use core::integer::{u128_safe_divmod, U32TryIntoNonZero};
+use core::option::OptionTrait;
+use core::traits::{Into, TryInto};
+use core::serde::Serde;
+use core::zeroable::NonZeroIntoImpl;
+
+/// A magic constant for identifying serialization of ByteArrays. An array of felt252s with this
+/// magic as one of the felt252s indicates that right after it you should expect a serialized
+/// ByteArray. This is currently used mainly for prints and panics.
+pub(crate) const BYTE_ARRAY_MAGIC: felt252 =
+    0x46a6158a16a947e5916b2a2ca68501a45e93d7110e81aa2d6438b1c57c879a3;
 const BYTES_IN_U128: usize = 16;
 // TODO(yuval): change to `BYTES_IN_BYTES31 - 1` once consteval_int supports non-literals.
 const BYTES_IN_BYTES31_MINUS_ONE: usize = consteval_int!(31 - 1);
 
 // TODO(yuval): don't allow creation of invalid ByteArray?
-#[derive(Drop, Clone, PartialEq)]
-struct ByteArray {
+#[derive(Drop, Clone, PartialEq, Serde, Default)]
+pub struct ByteArray {
     // Full "words" of 31 bytes each. The first byte of each word in the byte array
     // is the most significant byte in the word.
-    data: Array<bytes31>,
+    pub(crate) data: Array<bytes31>,
     // This felt252 actually represents a bytes31, with < 31 bytes.
     // It is represented as a felt252 to improve performance of building the byte array.
     // The number of bytes in here is specified in `pending_word_len`.
     // The first byte is the most significant byte among the `pending_word_len` bytes in the word.
-    pending_word: felt252,
+    pub(crate) pending_word: felt252,
     // Should be in range [0, 30].
-    pending_word_len: usize,
+    pub(crate) pending_word_len: usize,
 }
 
-impl ByteArrayDefault of Default<ByteArray> {
-    fn default() -> ByteArray {
-        ByteArray { data: Default::default(), pending_word: 0, pending_word_len: 0 }
-    }
-}
+pub(crate) impl ByteArrayStringLiteral of core::string::StringLiteral<ByteArray>;
 
 #[generate_trait]
-impl ByteArrayImpl of ByteArrayTrait {
+pub impl ByteArrayImpl of ByteArrayTrait {
     // TODO(yuval): add a `new` function for initialization.
 
     // Appends a single word of `len` bytes to the end of the ByteArray.
@@ -88,16 +90,7 @@ impl ByteArrayImpl of ByteArrayTrait {
         let mut other_data = other.data.span();
 
         if self.pending_word_len == 0 {
-            loop {
-                match other_data.pop_front() {
-                    Option::Some(current_word) => {
-                        self.data.append(*current_word);
-                    },
-                    Option::None => {
-                        break;
-                    }
-                };
-            };
+            self.data.append_span(other_data);
             self.pending_word = *other.pending_word;
             self.pending_word_len = *other.pending_word_len;
             return;
@@ -111,9 +104,7 @@ impl ByteArrayImpl of ByteArrayTrait {
                     Option::Some(current_word) => {
                         self.append_split_index_16((*current_word).into());
                     },
-                    Option::None => {
-                        break;
-                    }
+                    Option::None => { break; }
                 };
             };
         } else if self.pending_word_len < BYTES_IN_U128 {
@@ -125,9 +116,7 @@ impl ByteArrayImpl of ByteArrayTrait {
                                 (*current_word).into(), self.pending_word_len
                             );
                     },
-                    Option::None => {
-                        break;
-                    }
+                    Option::None => { break; }
                 };
             };
         } else {
@@ -140,9 +129,7 @@ impl ByteArrayImpl of ByteArrayTrait {
                                 (*current_word).into(), self.pending_word_len
                             );
                     },
-                    Option::None => {
-                        break;
-                    }
+                    Option::None => { break; }
                 };
             };
         }
@@ -180,6 +167,7 @@ impl ByteArrayImpl of ByteArrayTrait {
         self.pending_word_len = 0;
     }
 
+    #[must_use]
     fn len(self: @ByteArray) -> usize {
         self.data.len() * BYTES_IN_BYTES31.into() + (*self.pending_word_len).into()
     }
@@ -223,9 +211,7 @@ impl ByteArrayImpl of ByteArrayTrait {
                 Option::Some(current_word) => {
                     result.append_word_rev((*current_word).into(), BYTES_IN_BYTES31);
                 },
-                Option::None => {
-                    break;
-                }
+                Option::None => { break; }
             };
         };
         result
@@ -356,7 +342,7 @@ impl ByteArrayImpl of ByteArrayTrait {
     }
 }
 
-impl U128Add of Add<ByteArray> {
+impl ByteArrayAdd of Add<ByteArray> {
     #[inline]
     fn add(lhs: ByteArray, rhs: ByteArray) -> ByteArray {
         ByteArrayTrait::concat(@lhs, @rhs)
@@ -369,7 +355,7 @@ impl ByteArrayAddEq of AddEq<ByteArray> {
     }
 }
 
-impl ByteArrayIndexView of IndexView<ByteArray, usize, u8> {
+pub(crate) impl ByteArrayIndexView of IndexView<ByteArray, usize, u8> {
     fn index(self: @ByteArray, index: usize) -> u8 {
         self.at(index).expect('Index out of bounds')
     }
diff --git a/corelib/src/bytes_31.cairo b/corelib/src/bytes_31.cairo
index d4a913b..a5763c0 100644
--- a/corelib/src/bytes_31.cairo
+++ b/corelib/src/bytes_31.cairo
@@ -1,21 +1,21 @@
-use traits::{Into, TryInto};
-use option::OptionTrait;
-use integer::{u256_from_felt252, u128_safe_divmod, u128_to_felt252};
+use core::traits::{Into, TryInto};
+use core::option::OptionTrait;
+use core::integer::{u128_safe_divmod, u128_to_felt252};
 
-const BYTES_IN_BYTES31: usize = 31;
+pub(crate) const BYTES_IN_BYTES31: usize = 31;
 const BYTES_IN_U128: usize = 16;
-const POW_2_128: felt252 = 0x100000000000000000000000000000000;
-const POW_2_8: u128 = 0x100;
+pub(crate) const POW_2_128: felt252 = 0x100000000000000000000000000000000;
+pub(crate) const POW_2_8: u128 = 0x100;
 
 #[derive(Copy, Drop)]
-extern type bytes31;
+pub extern type bytes31;
 
-extern fn bytes31_const<const value: felt252>() -> bytes31 nopanic;
+pub(crate) extern fn bytes31_const<const value: felt252>() -> bytes31 nopanic;
 extern fn bytes31_try_from_felt252(value: felt252) -> Option<bytes31> implicits(RangeCheck) nopanic;
 extern fn bytes31_to_felt252(value: bytes31) -> felt252 nopanic;
 
 #[generate_trait]
-impl Bytes31Impl of Bytes31Trait {
+pub impl Bytes31Impl of Bytes31Trait {
     // Gets the byte at the given index (LSB's index is 0), assuming that
     // `index < BYTES_IN_BYTES31`. If the assumption is not met, the behavior is undefined.
     fn at(self: @bytes31, index: usize) -> u8 {
@@ -29,60 +29,62 @@ impl Bytes31Impl of Bytes31Trait {
     }
 }
 
-impl Bytes31IndexView of IndexView<bytes31, usize, u8> {
+pub(crate) impl Bytes31IndexView of IndexView<bytes31, usize, u8> {
     fn index(self: @bytes31, index: usize) -> u8 {
         self.at(index)
     }
 }
 
-impl Bytes31IntoFelt252 of Into<bytes31, felt252> {
+impl Bytes31BitSize of core::num::traits::BitSize<bytes31> {
+    fn bits() -> usize {
+        248
+    }
+}
+
+pub(crate) impl Bytes31IntoFelt252 of Into<bytes31, felt252> {
     fn into(self: bytes31) -> felt252 {
         bytes31_to_felt252(self)
     }
 }
 
-impl Bytes31IntoU256 of Into<bytes31, u256> {
+pub(crate) impl Bytes31IntoU256 of Into<bytes31, u256> {
     fn into(self: bytes31) -> u256 {
         let as_felt: felt252 = self.into();
         as_felt.into()
     }
 }
 
-impl Felt252TryIntoBytes31 of TryInto<felt252, bytes31> {
+pub(crate) impl Felt252TryIntoBytes31 of TryInto<felt252, bytes31> {
     fn try_into(self: felt252) -> Option<bytes31> {
         bytes31_try_from_felt252(self)
     }
 }
 
-// TODO(yuval): implement all `into`s using `integer::upcast(self)`.
-impl U8IntoBytes31 of Into<u8, bytes31> {
+impl Bytes31Serde = core::serde::into_felt252_based::SerdeImpl<bytes31>;
+
+pub(crate) impl U8IntoBytes31 of Into<u8, bytes31> {
     fn into(self: u8) -> bytes31 {
-        let as_felt: felt252 = self.into();
-        as_felt.try_into().unwrap()
+        core::integer::upcast(self)
     }
 }
 impl U16IntoBytes31 of Into<u16, bytes31> {
     fn into(self: u16) -> bytes31 {
-        let as_felt: felt252 = self.into();
-        as_felt.try_into().unwrap()
+        core::integer::upcast(self)
     }
 }
 impl U32IntoBytes31 of Into<u32, bytes31> {
     fn into(self: u32) -> bytes31 {
-        let as_felt: felt252 = self.into();
-        as_felt.try_into().unwrap()
+        core::integer::upcast(self)
     }
 }
 impl U64IntoBytes31 of Into<u64, bytes31> {
     fn into(self: u64) -> bytes31 {
-        let as_felt: felt252 = self.into();
-        as_felt.try_into().unwrap()
+        core::integer::upcast(self)
     }
 }
-impl U128IntoBytes31 of Into<u128, bytes31> {
+pub(crate) impl U128IntoBytes31 of Into<u128, bytes31> {
     fn into(self: u128) -> bytes31 {
-        let as_felt: felt252 = self.into();
-        as_felt.try_into().unwrap()
+        core::integer::upcast(self)
     }
 }
 
@@ -94,7 +96,7 @@ impl U128IntoBytes31 of Into<u128, bytes31> {
 // 3. len <= BYTES_IN_BYTES31.
 // If these assumptions are not met, it can corrupt the ByteArray. Thus, this should be a
 // private function. We could add masking/assertions but it would be more expansive.
-fn split_bytes31(word: felt252, len: usize, index: usize) -> (felt252, felt252) {
+pub(crate) fn split_bytes31(word: felt252, len: usize, index: usize) -> (felt252, felt252) {
     if index == 0 {
         return (0, word);
     }
@@ -139,7 +141,7 @@ fn split_bytes31(word: felt252, len: usize, index: usize) -> (felt252, felt252)
 // Note: if `n_bytes >= BYTES_IN_BYTES31`, the behavior is undefined. If one wants to assert that in
 // the callsite, it's sufficient to assert that `n_bytes != BYTES_IN_BYTES31` because if
 // `n_bytes > 31` then `n_bytes - 16 > 15` and `one_shift_left_bytes_u128` would panic.
-fn one_shift_left_bytes_felt252(n_bytes: usize) -> felt252 {
+pub(crate) fn one_shift_left_bytes_felt252(n_bytes: usize) -> felt252 {
     if n_bytes < BYTES_IN_U128 {
         one_shift_left_bytes_u128(n_bytes).into()
     } else {
@@ -150,7 +152,7 @@ fn one_shift_left_bytes_felt252(n_bytes: usize) -> felt252 {
 // Returns 1 << (8 * `n_bytes`) as u128, where `n_bytes` must be < BYTES_IN_U128.
 //
 // Panics if `n_bytes >= BYTES_IN_U128`.
-fn one_shift_left_bytes_u128(n_bytes: usize) -> u128 {
+pub(crate) fn one_shift_left_bytes_u128(n_bytes: usize) -> u128 {
     // TODO(yuval): change to match once it's supported for integers.
     if n_bytes == 0 {
         0x1_u128
@@ -185,7 +187,7 @@ fn one_shift_left_bytes_u128(n_bytes: usize) -> u128 {
     } else if n_bytes == 15 {
         0x1000000000000000000000000000000_u128
     } else {
-        panic_with_felt252('n_bytes too big')
+        core::panic_with_felt252('n_bytes too big')
     }
 }
 
diff --git a/corelib/src/clone.cairo b/corelib/src/clone.cairo
index fc71f20..3a27f99 100644
--- a/corelib/src/clone.cairo
+++ b/corelib/src/clone.cairo
@@ -1,8 +1,9 @@
-trait Clone<T> {
+pub trait Clone<T> {
+    #[must_use]
     fn clone(self: @T) -> T;
 }
 
-impl TCopyClone<T, impl TCopy: Copy<T>> of Clone<T> {
+impl TCopyClone<T, +Copy<T>> of Clone<T> {
     fn clone(self: @T) -> T {
         *self
     }
diff --git a/corelib/src/cmp.cairo b/corelib/src/cmp.cairo
index 3031ce1..a458570 100644
--- a/corelib/src/cmp.cairo
+++ b/corelib/src/cmp.cairo
@@ -1,15 +1,13 @@
-fn min<T, impl TPartialOrd: PartialOrd<T>, impl DropT: Drop<T>, impl CopyT: Copy<T>>(
-    a: T, b: T
-) -> T {
+#[must_use]
+pub fn min<T, +PartialOrd<T>, +Drop<T>, +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 {
+#[must_use]
+pub fn max<T, +PartialOrd<T>, +Drop<T>, +Copy<T>>(a: T, b: T) -> T {
     if a > b {
         return a;
     }
diff --git a/corelib/src/debug.cairo b/corelib/src/debug.cairo
index e5ce405..f325f34 100644
--- a/corelib/src/debug.cairo
+++ b/corelib/src/debug.cairo
@@ -1,10 +1,10 @@
-use array::ArrayTrait;
-use traits::Into;
-use option::Option;
+use core::array::ArrayTrait;
+use core::traits::Into;
+use core::option::Option;
 
 // Usage:
 //
-// use debug::PrintTrait;
+// use core::debug::PrintTrait;
 //
 // 1.print();
 //
@@ -18,23 +18,23 @@ use option::Option;
 // arr.append('SomeVeryLongMessage');
 // arr.print();
 
-extern fn print(message: Array<felt252>) nopanic;
+pub(crate) extern fn print(message: Array<felt252>) nopanic;
 
 fn print_felt252(message: felt252) {
     print(array![message]);
 }
 
-trait PrintTrait<T> {
+pub(crate) trait PrintTrait<T> {
     fn print(self: T);
 }
 
-impl Felt252PrintImpl of PrintTrait<felt252> {
+pub(crate) impl Felt252PrintImpl of PrintTrait<felt252> {
     fn print(self: felt252) {
         print_felt252(self);
     }
 }
 
-impl BoolPrintImpl of PrintTrait<bool> {
+pub(crate) impl BoolPrintImpl of PrintTrait<bool> {
     fn print(self: bool) {
         if self {
             'true'.print();
@@ -44,51 +44,89 @@ impl BoolPrintImpl of PrintTrait<bool> {
     }
 }
 
-impl ContractAddressPrintImpl of PrintTrait<starknet::ContractAddress> {
+pub(crate) impl ContractAddressPrintImpl of PrintTrait<starknet::ContractAddress> {
     fn print(self: starknet::ContractAddress) {
         Into::<_, felt252>::into(self).print();
     }
 }
 
-impl U8PrintImpl of PrintTrait<u8> {
+pub(crate) impl U8PrintImpl of PrintTrait<u8> {
     fn print(self: u8) {
         Into::<_, felt252>::into(self).print();
     }
 }
 
-impl U16PrintImpl of PrintTrait<u16> {
+pub(crate) impl U16PrintImpl of PrintTrait<u16> {
     fn print(self: u16) {
         Into::<_, felt252>::into(self).print();
     }
 }
 
-impl U32PrintImpl of PrintTrait<u32> {
+pub(crate) impl U32PrintImpl of PrintTrait<u32> {
     fn print(self: u32) {
         Into::<_, felt252>::into(self).print();
     }
 }
 
-impl U64PrintImpl of PrintTrait<u64> {
+pub(crate) impl U64PrintImpl of PrintTrait<u64> {
     fn print(self: u64) {
         Into::<_, felt252>::into(self).print();
     }
 }
 
-impl U128PrintImpl of PrintTrait<u128> {
+pub(crate) impl U128PrintImpl of PrintTrait<u128> {
     fn print(self: u128) {
         Into::<_, felt252>::into(self).print();
     }
 }
 
-impl U256PrintImpl of PrintTrait<u256> {
+pub(crate) 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>> {
+pub(crate) impl I8PrintImpl of PrintTrait<i8> {
+    fn print(self: i8) {
+        Into::<_, felt252>::into(self).print();
+    }
+}
+
+pub(crate) impl I16PrintImpl of PrintTrait<i16> {
+    fn print(self: i16) {
+        Into::<_, felt252>::into(self).print();
+    }
+}
+
+pub(crate) impl I32PrintImpl of PrintTrait<i32> {
+    fn print(self: i32) {
+        Into::<_, felt252>::into(self).print();
+    }
+}
+
+pub(crate) impl I64PrintImpl of PrintTrait<i64> {
+    fn print(self: i64) {
+        Into::<_, felt252>::into(self).print();
+    }
+}
+
+pub(crate) impl I128PrintImpl of PrintTrait<i128> {
+    fn print(self: i128) {
+        Into::<_, felt252>::into(self).print();
+    }
+}
+
+pub(crate) impl ArrayGenericPrintImpl of PrintTrait<Array<felt252>> {
     fn print(mut self: Array<felt252>) {
         print(self);
     }
 }
+
+/// Prints a byte array as a string.
+pub fn print_byte_array_as_string(self: @ByteArray) {
+    let mut serialized = array![core::byte_array::BYTE_ARRAY_MAGIC];
+    self.serialize(ref serialized);
+    print(serialized)
+}
+
diff --git a/corelib/src/dict.cairo b/corelib/src/dict.cairo
index ba6f294..b6de59f 100644
--- a/corelib/src/dict.cairo
+++ b/corelib/src/dict.cairo
@@ -1,11 +1,11 @@
-use traits::{Index, Default};
+use core::traits::{Index, Default, Felt252DictValue};
 
-extern type Felt252Dict<T>;
-extern type SquashedFelt252Dict<T>;
-extern type Felt252DictEntry<T>;
-impl SquashedFelt252DictDrop<T, impl TDrop: Drop<T>> of Drop<SquashedFelt252Dict<T>>;
+pub extern type Felt252Dict<T>;
+pub extern type SquashedFelt252Dict<T>;
+pub extern type Felt252DictEntry<T>;
+impl SquashedFelt252DictDrop<T, +Drop<T>> of Drop<SquashedFelt252Dict<T>>;
 
-extern fn felt252_dict_new<T>() -> Felt252Dict<T> implicits(SegmentArena) nopanic;
+pub(crate) extern fn felt252_dict_new<T>() -> Felt252Dict<T> implicits(SegmentArena) nopanic;
 
 extern fn felt252_dict_entry_get<T>(
     dict: Felt252Dict<T>, key: felt252
@@ -20,31 +20,32 @@ extern fn felt252_dict_entry_finalize<T>(
 /// NOTE: Never use this libfunc directly. Use Felt252DictTrait::squash() instead. Using this
 /// libfunc directly will result in multiple unnecessary copies of the libfunc in the compiled CASM
 /// code.
-extern fn felt252_dict_squash<T>(
+pub(crate) extern fn felt252_dict_squash<T>(
     dict: Felt252Dict<T>
 ) -> SquashedFelt252Dict<T> implicits(RangeCheck, GasBuiltin, SegmentArena) nopanic;
 
-trait Felt252DictTrait<T> {
+pub trait Felt252DictTrait<T> {
     /// Inserts the given value for the given key.
     ///
     /// Requires the `Destruct` trait, as the previous value is dropped.
-    fn insert<impl TDestruct: Destruct<T>>(ref self: Felt252Dict<T>, key: felt252, value: T);
+    fn insert<+Destruct<T>>(ref self: Felt252Dict<T>, key: felt252, value: T);
     /// Returns a copy of the value at the given key.
     ///
     /// Requires the `Copy` trait.
-    fn get<impl TCopy: Copy<T>>(ref self: Felt252Dict<T>, key: felt252) -> T;
+    fn get<+Copy<T>>(ref self: Felt252Dict<T>, key: felt252) -> T;
     fn squash(self: Felt252Dict<T>) -> SquashedFelt252Dict<T> nopanic;
+    #[must_use]
     fn entry(self: Felt252Dict<T>, key: felt252) -> (Felt252DictEntry<T>, T) nopanic;
 }
-impl Felt252DictImpl<T, impl TDefault: Felt252DictValue<T>> of Felt252DictTrait<T> {
+impl Felt252DictImpl<T, +Felt252DictValue<T>> of Felt252DictTrait<T> {
     #[inline]
-    fn insert<impl TDestruct: Destruct<T>>(ref self: Felt252Dict<T>, key: felt252, value: T) {
+    fn insert<+Destruct<T>>(ref self: Felt252Dict<T>, key: felt252, value: T) {
         let (entry, _prev_value) = felt252_dict_entry_get(self, key);
         self = felt252_dict_entry_finalize(entry, value);
     }
 
     #[inline]
-    fn get<impl TCopy: Copy<T>>(ref self: Felt252Dict<T>, key: felt252) -> T {
+    fn get<+Copy<T>>(ref self: Felt252Dict<T>, key: felt252) -> T {
         let (entry, prev_value) = felt252_dict_entry_get(self, key);
         let return_value = prev_value;
         self = felt252_dict_entry_finalize(entry, prev_value);
@@ -62,11 +63,11 @@ impl Felt252DictImpl<T, impl TDefault: Felt252DictValue<T>> of Felt252DictTrait<
     }
 }
 
-trait Felt252DictEntryTrait<T> {
+pub trait Felt252DictEntryTrait<T> {
     fn finalize(self: Felt252DictEntry<T>, new_value: T) -> Felt252Dict<T>;
 }
 
-impl Felt252DictEntryImpl<T, impl TDefault: Felt252DictValue<T>> of Felt252DictEntryTrait<T> {
+impl Felt252DictEntryImpl<T, +Felt252DictValue<T>> of Felt252DictEntryTrait<T> {
     #[inline(always)]
     fn finalize(self: Felt252DictEntry<T>, new_value: T) -> Felt252Dict<T> {
         felt252_dict_entry_finalize(self, new_value)
@@ -80,29 +81,22 @@ impl Felt252DictDefault<T> of Default<Felt252Dict<T>> {
     }
 }
 
-impl Felt252DictDestruct<
-    T, impl TDrop: Drop<T>, impl TDefault: Felt252DictValue<T>
-> of Destruct<Felt252Dict<T>> {
+impl Felt252DictDestruct<T, +Drop<T>, +Felt252DictValue<T>> of Destruct<Felt252Dict<T>> {
     #[inline(always)]
     fn destruct(self: Felt252Dict<T>) nopanic {
         self.squash();
     }
 }
 
-impl Felt252DictEntryDestruct<
-    T, impl TDrop: Drop<T>, impl TDefault: Felt252DictValue<T>
-> of Destruct<Felt252DictEntry<T>> {
+impl Felt252DictEntryDestruct<T, +Drop<T>, +Felt252DictValue<T>> of Destruct<Felt252DictEntry<T>> {
     #[inline(always)]
     fn destruct(self: Felt252DictEntry::<T>) nopanic {
-        felt252_dict_entry_finalize(self, TDefault::zero_default());
+        felt252_dict_entry_finalize(self, Felt252DictValue::zero_default());
     }
 }
 
 impl Felt252DictIndex<
-    T,
-    impl TDictImpl: Felt252DictTrait<T>,
-    impl TCopy: Copy<T>,
-    impl EntryDestruct: Destruct<Felt252DictEntry<T>>
+    T, +Felt252DictTrait<T>, +Copy<T>, +Destruct<Felt252DictEntry<T>>
 > of Index<Felt252Dict<T>, felt252, T> {
     #[inline(always)]
     fn index(ref self: Felt252Dict<T>, index: felt252) -> T {
diff --git a/corelib/src/ec.cairo b/corelib/src/ec.cairo
index 46c4da9..91123fe 100644
--- a/corelib/src/ec.cairo
+++ b/corelib/src/ec.cairo
@@ -1,27 +1,27 @@
 //! This module contains functions and constructs related to elliptic curve operations on the Stark
 //! curve.
 
-use array::ArrayTrait;
-use traits::{Into, TryInto};
-use zeroable::IsZeroResult;
+use core::array::ArrayTrait;
+use core::traits::{Into, TryInto};
+use core::zeroable::IsZeroResult;
 
-mod stark_curve {
+pub mod stark_curve {
     /// The STARK Curve is defined by the equation `y^2 = x^3 + ALPHA*x + BETA`.
-    const ALPHA: felt252 = 1;
+    pub const ALPHA: felt252 = 1;
     /// The STARK Curve is defined by the equation `y^2 = x^3 + ALPHA*x + BETA`.
-    const BETA: felt252 = 0x6f21413efbe40de150e596d72f7a8c5609ad26c15c915c1f4cdfcb99cee9e89;
+    pub const BETA: felt252 = 0x6f21413efbe40de150e596d72f7a8c5609ad26c15c915c1f4cdfcb99cee9e89;
     /// The order (number of points) of the STARK Curve.
-    const ORDER: felt252 = 0x800000000000010ffffffffffffffffb781126dcae7b2321e66a241adc64d2f;
+    pub const ORDER: felt252 = 0x800000000000010ffffffffffffffffb781126dcae7b2321e66a241adc64d2f;
     /// The x coordinate of the generator point used in the ECDSA signature.
-    const GEN_X: felt252 = 0x1ef15c18599971b7beced415a40f0c7deacfd9b0d1819e03d723d8bc943cfca;
+    pub const GEN_X: felt252 = 0x1ef15c18599971b7beced415a40f0c7deacfd9b0d1819e03d723d8bc943cfca;
     /// The y coordinate of the generator point used in the ECDSA signature.
-    const GEN_Y: felt252 = 0x5668060aa49730b7be4801df46ec62de53ecd11abe43a32873000c36e8dc1f;
+    pub const GEN_Y: felt252 = 0x5668060aa49730b7be4801df46ec62de53ecd11abe43a32873000c36e8dc1f;
 }
 
-extern type EcOp;
+pub extern type EcOp;
 #[derive(Copy, Drop)]
-extern type EcPoint;
-type NonZeroEcPoint = NonZero<EcPoint>;
+pub extern type EcPoint;
+pub type NonZeroEcPoint = NonZero<EcPoint>;
 
 /// Returns the zero point of the curve ("the point at infinity").
 extern fn ec_point_zero() -> EcPoint nopanic;
@@ -32,7 +32,7 @@ extern fn ec_point_try_new_nz(x: felt252, y: felt252) -> Option<NonZeroEcPoint>
 /// Returns `None` if no point of form (x, _) is on the curve.
 extern fn ec_point_from_x_nz(x: felt252) -> Option<NonZeroEcPoint> implicits(RangeCheck) nopanic;
 /// Unwraps a non-zero point into its (x, y) coordinates.
-extern fn ec_point_unwrap(p: NonZeroEcPoint) -> (felt252, felt252) nopanic;
+pub extern fn ec_point_unwrap(p: NonZeroEcPoint) -> (felt252, felt252) nopanic;
 /// Computes the negation of an elliptic curve point (-p).
 extern fn ec_neg(p: EcPoint) -> EcPoint nopanic;
 /// Checks whether the given `EcPoint` is the zero point.
@@ -53,7 +53,7 @@ impl EcPointTryIntoNonZero of TryInto<EcPoint, NonZeroEcPoint> {
 
 // TODO(lior): Allow explicit clone() for EcState, since we don't allow implicit dup (Copy).
 #[derive(Drop)]
-extern type EcState;
+pub extern type EcState;
 
 /// Initializes an EC computation with the zero point.
 extern fn ec_state_init() -> EcState nopanic;
@@ -69,8 +69,9 @@ extern fn ec_state_add_mul(
 extern fn ec_state_try_finalize_nz(s: EcState) -> Option<NonZeroEcPoint> nopanic;
 
 #[generate_trait]
-impl EcStateImpl of EcStateTrait {
+pub impl EcStateImpl of EcStateTrait {
     /// Initializes an EC computation with the zero point.
+    #[must_use]
     fn init() -> EcState {
         ec_state_init()
     }
@@ -101,7 +102,7 @@ impl EcStateImpl of EcStateTrait {
 }
 
 #[generate_trait]
-impl EcPointImpl of EcPointTrait {
+pub impl EcPointImpl of EcPointTrait {
     /// Creates a new EC point from its (x, y) coordinates.
     #[inline(always)]
     fn new(x: felt252, y: felt252) -> Option<EcPoint> {
@@ -142,15 +143,11 @@ impl EcPointAdd of Add<EcPoint> {
     fn add(lhs: EcPoint, rhs: EcPoint) -> EcPoint {
         let lhs_nz = match lhs.try_into() {
             Option::Some(pt) => pt,
-            Option::None => {
-                return rhs;
-            },
+            Option::None => { return rhs; },
         };
         let rhs_nz = match rhs.try_into() {
             Option::Some(pt) => pt,
-            Option::None => {
-                return lhs;
-            },
+            Option::None => { return lhs; },
         };
         let mut state = ec_state_init();
         state.add(lhs_nz);
@@ -169,7 +166,8 @@ impl EcPointAddEq of AddEq<EcPoint> {
 impl EcPointSub of Sub<EcPoint> {
     /// Computes the difference between two points on the curve.
     fn sub(lhs: EcPoint, rhs: EcPoint) -> EcPoint {
-        match rhs.try_into() {
+        let nz_point: Option<NonZero<EcPoint>> = rhs.try_into();
+        match nz_point {
             Option::Some(_) => {},
             Option::None => {
                 // lhs - 0 = lhs.
diff --git a/corelib/src/ecdsa.cairo b/corelib/src/ecdsa.cairo
index 6037b30..450e586 100644
--- a/corelib/src/ecdsa.cairo
+++ b/corelib/src/ecdsa.cairo
@@ -1,7 +1,8 @@
-use ec::EcPointTrait;
-use option::OptionTrait;
-use traits::{Into, TryInto};
-use zeroable::IsZeroResult;
+use core::{ec, ec::{EcPoint, EcPointTrait}};
+use core::option::OptionTrait;
+use core::math;
+use core::traits::{Into, TryInto};
+use core::zeroable::IsZeroResult;
 
 // Checks if (`signature_r`, `signature_s`) is a valid ECDSA signature for the given `public_key`
 // on the given `message`.
@@ -21,7 +22,7 @@ use zeroable::IsZeroResult;
 // Returns:
 //   `true` if the signature is valid and `false` otherwise.
 // TODO(lior): Make this function nopanic once possible.
-fn check_ecdsa_signature(
+pub fn check_ecdsa_signature(
     message_hash: felt252, public_key: felt252, signature_r: felt252, signature_s: felt252
 ) -> bool {
     // TODO(orizi): Change to || once it does not prevent `a == 0` comparison optimization.
@@ -37,28 +38,22 @@ fn check_ecdsa_signature(
     }
 
     // Check that the public key is the x coordinate of a point on the curve and get such a point.
-    let public_key_point = match ec::EcPointTrait::new_from_x(public_key) {
+    let public_key_point = match EcPointTrait::new_from_x(public_key) {
         Option::Some(point) => point,
-        Option::None => {
-            return false;
-        },
+        Option::None => { return false; },
     };
 
     // Check that `r` is the x coordinate of a point on the curve and get such a point.
     // Note that this ensures that `r != 0`.
     let signature_r_point = match EcPointTrait::new_from_x(signature_r) {
         Option::Some(point) => point,
-        Option::None => {
-            return false;
-        },
+        Option::None => { return false; },
     };
 
     // Retrieve the generator point.
     let gen_point = match EcPointTrait::new(ec::stark_curve::GEN_X, ec::stark_curve::GEN_Y) {
         Option::Some(point) => point,
-        Option::None => {
-            return false;
-        },
+        Option::None => { return false; },
     };
 
     // To verify ECDSA, obtain:
@@ -74,9 +69,7 @@ fn check_ecdsa_signature(
             let (x, _) = ec::ec_point_unwrap(pt);
             x
         },
-        Option::None => {
-            return false;
-        },
+        Option::None => { return false; },
     };
 
     let zG: EcPoint = gen_point.mul(message_hash);
@@ -106,7 +99,7 @@ fn check_ecdsa_signature(
 
 /// Receives a signature and the signed message hash.
 /// Returns the public key associated with the signer.
-fn recover_public_key(
+pub fn recover_public_key(
     message_hash: felt252, signature_r: felt252, signature_s: felt252, y_parity: bool
 ) -> Option<felt252> {
     let mut signature_r_point = EcPointTrait::new_from_x(signature_r)?;
@@ -136,7 +129,7 @@ fn recover_public_key(
     let r_nz = r_nz.try_into()?;
     let ord_nz: u256 = ec::stark_curve::ORDER.into();
     let ord_nz = ord_nz.try_into()?;
-    let r_inv = math::inv_mod(r_nz, ord_nz)?;
+    let r_inv = math::u256_inv_mod(r_nz, ord_nz)?.into();
     let s_div_r: felt252 = math::u256_mul_mod_n(signature_s.into(), r_inv, ord_nz).try_into()?;
     let z_div_r: felt252 = math::u256_mul_mod_n(message_hash.into(), r_inv, ord_nz).try_into()?;
     let s_div_rR: EcPoint = signature_r_point.mul(s_div_r);
diff --git a/corelib/src/felt_252.cairo b/corelib/src/felt_252.cairo
new file mode 100644
index 0000000..f1f9f1e
--- /dev/null
+++ b/corelib/src/felt_252.cairo
@@ -0,0 +1,31 @@
+pub(crate) impl Felt252Zero of core::num::traits::Zero<felt252> {
+    fn zero() -> felt252 {
+        0
+    }
+
+    #[inline(always)]
+    fn is_zero(self: @felt252) -> bool {
+        *self == Felt252Zero::zero()
+    }
+
+    #[inline(always)]
+    fn is_non_zero(self: @felt252) -> bool {
+        !self.is_zero()
+    }
+}
+
+pub(crate) impl Felt252One of core::num::traits::One<felt252> {
+    fn one() -> felt252 {
+        1
+    }
+
+    #[inline(always)]
+    fn is_one(self: @felt252) -> bool {
+        *self == Felt252One::one()
+    }
+
+    #[inline(always)]
+    fn is_non_one(self: @felt252) -> bool {
+        !self.is_one()
+    }
+}
diff --git a/corelib/src/fmt.cairo b/corelib/src/fmt.cairo
new file mode 100644
index 0000000..506d72a
--- /dev/null
+++ b/corelib/src/fmt.cairo
@@ -0,0 +1,198 @@
+#[derive(Drop)]
+pub struct Error {}
+
+/// Configuration for formatting.
+#[derive(Default, Drop)]
+pub struct Formatter {
+    /// The pending result of formatting.
+    pub buffer: ByteArray,
+}
+
+/// A trait for standard formatting, using the empty format ("{}").
+pub trait Display<T> {
+    fn fmt(self: @T, ref f: Formatter) -> Result<(), Error>;
+}
+
+impl DisplayByteArray of Display<ByteArray> {
+    fn fmt(self: @ByteArray, ref f: Formatter) -> Result<(), Error> {
+        f.buffer.append(self);
+        Result::Ok(())
+    }
+}
+
+impl DisplayInteger<
+    T, +to_byte_array::AppendFormattedToByteArray<T>, +Into<u8, T>, +TryInto<T, NonZero<T>>
+> of Display<T> {
+    fn fmt(self: @T, ref f: Formatter) -> Result<(), Error> {
+        // TODO(yuval): determine base according to Formatter parameters.
+        let base: T = 10_u8.into();
+        self.append_formatted_to_byte_array(ref f.buffer, base.try_into().unwrap());
+        Result::Ok(())
+    }
+}
+
+impl DisplayNonZero<T, +Display<T>, +Copy<T>, +Drop<T>> of Display<NonZero<T>> {
+    fn fmt(self: @NonZero<T>, ref f: Formatter) -> Result<(), Error> {
+        let value: T = (*self).into();
+        write!(f, "{value}")
+    }
+}
+
+impl DisplayBool of Display<bool> {
+    fn fmt(self: @bool, ref f: Formatter) -> Result<(), Error> {
+        if *self {
+            write!(f, "true")
+        } else {
+            write!(f, "false")
+        }
+    }
+}
+
+/// A trait for debug formatting, using the empty format ("{:?}").
+pub trait Debug<T> {
+    fn fmt(self: @T, ref f: Formatter) -> Result<(), Error>;
+}
+
+impl DebugByteArray of Debug<ByteArray> {
+    fn fmt(self: @ByteArray, ref f: Formatter) -> Result<(), Error> {
+        write!(f, "\"")?;
+        Display::fmt(self, ref f)?;
+        write!(f, "\"")
+    }
+}
+
+impl DebugInteger<
+    T, +to_byte_array::AppendFormattedToByteArray<T>, +Into<u8, T>, +TryInto<T, NonZero<T>>
+> of Debug<T> {
+    fn fmt(self: @T, ref f: Formatter) -> Result<(), Error> {
+        Display::fmt(self, ref f)
+    }
+}
+
+impl DebugNonZero<T, +Debug<T>, +Copy<T>, +Drop<T>> of Debug<NonZero<T>> {
+    fn fmt(self: @NonZero<T>, ref f: Formatter) -> Result<(), Error> {
+        let value: T = (*self).into();
+        write!(f, "{value:?}")
+    }
+}
+
+impl DebugBool of Debug<bool> {
+    fn fmt(self: @bool, ref f: Formatter) -> Result<(), Error> {
+        Display::fmt(self, ref f)
+    }
+}
+
+impl DebugSnapshot<T, +Debug<T>> of Debug<@T> {
+    fn fmt(self: @@T, ref f: Formatter) -> Result<(), Error> {
+        write!(f, "@")?;
+        Debug::fmt(*self, ref f)
+    }
+}
+
+impl DebugTuple0 of Debug<()> {
+    fn fmt(self: @(), ref f: Formatter) -> Result<(), Error> {
+        write!(f, "()")
+    }
+}
+
+impl DebugTuple1<E0, impl E0Debug: Debug<E0>> of Debug<(E0,)> {
+    fn fmt(self: @(E0,), ref f: Formatter) -> Result<(), Error> {
+        let (e0,) = self;
+        write!(f, "(")?;
+        E0Debug::fmt(e0, ref f)?;
+        write!(f, ",)")
+    }
+}
+
+impl DebugTuple2<E0, E1, impl E0Debug: Debug<E0>, impl E1Debug: Debug<E1>> of Debug<(E0, E1)> {
+    fn fmt(self: @(E0, E1), ref f: Formatter) -> Result<(), Error> {
+        let (e0, e1) = self;
+        write!(f, "(")?;
+        E0Debug::fmt(e0, ref f)?;
+        write!(f, ", ")?;
+        E1Debug::fmt(e1, ref f)?;
+        write!(f, ")")
+    }
+}
+
+impl DebugTuple3<
+    E0, E1, E2, impl E0Debug: Debug<E0>, impl E1Debug: Debug<E1>, impl E2Debug: Debug<E2>
+> of Debug<(E0, E1, E2)> {
+    fn fmt(self: @(E0, E1, E2), ref f: Formatter) -> Result<(), Error> {
+        let (e0, e1, e2) = self;
+        write!(f, "(")?;
+        E0Debug::fmt(e0, ref f)?;
+        write!(f, ", ")?;
+        E1Debug::fmt(e1, ref f)?;
+        write!(f, ", ")?;
+        E2Debug::fmt(e2, ref f)?;
+        write!(f, ")")
+    }
+}
+
+impl DebugTuple4<
+    E0,
+    E1,
+    E2,
+    E3,
+    impl E0Debug: Debug<E0>,
+    impl E1Debug: Debug<E1>,
+    impl E2Debug: Debug<E2>,
+    impl E3Debug: Debug<E3>
+> of Debug<(E0, E1, E2, E3)> {
+    fn fmt(self: @(E0, E1, E2, E3), ref f: Formatter) -> Result<(), Error> {
+        let (e0, e1, e2, e3) = self;
+        write!(f, "(")?;
+        E0Debug::fmt(e0, ref f)?;
+        write!(f, ", ")?;
+        E1Debug::fmt(e1, ref f)?;
+        write!(f, ", ")?;
+        E2Debug::fmt(e2, ref f)?;
+        write!(f, ", ")?;
+        E3Debug::fmt(e3, ref f)?;
+        write!(f, ")")
+    }
+}
+
+impl ArrayTDebug<T, +Debug<T>> of Debug<Array<T>> {
+    fn fmt(self: @Array<T>, ref f: Formatter) -> Result<(), Error> {
+        Debug::fmt(@self.span(), ref f)
+    }
+}
+
+impl SpanTDebug<T, +Debug<T>> of Debug<Span<T>> {
+    fn fmt(self: @Span<T>, ref f: Formatter) -> Result<(), Error> {
+        let mut self = *self;
+        write!(f, "[")?;
+        loop {
+            match self.pop_front() {
+                Option::Some(value) => {
+                    if Debug::fmt(value, ref f).is_err() {
+                        break Result::Err(Error {});
+                    };
+                    if self.is_empty() {
+                        break Result::Ok(());
+                    }
+                    if write!(f, ", ").is_err() {
+                        break Result::Err(Error {});
+                    };
+                },
+                Option::None => { break Result::Ok(()); }
+            };
+        }?;
+        write!(f, "]")
+    }
+}
+
+/// Impls for `Debug` for types that can be converted into `felt252` using the `Into` trait.
+/// Usage example:
+/// ```ignore
+/// impl MyTypeDebug = core::fmt::into_felt252_based::DebugImpl<MyType>;`
+/// ```
+pub mod into_felt252_based {
+    pub impl DebugImpl<T, +Into<T, felt252>, +Copy<T>> of core::fmt::Debug<T> {
+        fn fmt(self: @T, ref f: core::fmt::Formatter) -> Result<(), core::fmt::Error> {
+            core::fmt::DebugInteger::<felt252>::fmt(@(*self).into(), ref f)
+        }
+    }
+}
diff --git a/corelib/src/gas.cairo b/corelib/src/gas.cairo
index 229dce2..6ef2c70 100644
--- a/corelib/src/gas.cairo
+++ b/corelib/src/gas.cairo
@@ -1,9 +1,9 @@
 #[derive(Copy, Drop)]
-extern type BuiltinCosts;
-extern type GasBuiltin;
+pub extern type BuiltinCosts;
+pub extern type GasBuiltin;
 
-extern fn withdraw_gas() -> Option<()> implicits(RangeCheck, GasBuiltin) nopanic;
-extern fn withdraw_gas_all(
+pub extern fn withdraw_gas() -> Option<()> implicits(RangeCheck, GasBuiltin) nopanic;
+pub extern fn withdraw_gas_all(
     costs: BuiltinCosts
 ) -> Option<()> implicits(RangeCheck, GasBuiltin) nopanic;
-extern fn get_builtin_costs() -> BuiltinCosts nopanic;
+pub extern fn get_builtin_costs() -> BuiltinCosts nopanic;
diff --git a/corelib/src/hash.cairo b/corelib/src/hash.cairo
index effea00..5556f02 100644
--- a/corelib/src/hash.cairo
+++ b/corelib/src/hash.cairo
@@ -1,128 +1,94 @@
-use traits::Into;
-use starknet::ContractAddress;
+use core::traits::Into;
 
 /// A trait for hash state accumulators.
-trait HashStateTrait<S> {
+pub trait HashStateTrait<S> {
+    #[must_use]
     fn update(self: S, value: felt252) -> S;
+    #[must_use]
     fn finalize(self: S) -> felt252;
 }
 
 /// A trait for values that can be hashed.
-trait Hash<T, S, impl SHashState: HashStateTrait<S>> {
+pub trait Hash<T, S, +HashStateTrait<S>> {
     /// Updates the hash state with the given value.
+    #[must_use]
     fn update_state(state: S, value: T) -> S;
 }
 
 /// Trait for hashing values.
 /// Used for backwards compatibility.
 /// NOTE: Implement `Hash` instead of this trait if possible.
-trait LegacyHash<T> {
+pub trait LegacyHash<T> {
+    #[must_use]
     fn hash(state: felt252, value: T) -> felt252;
 }
 
 /// Implementation of `LegacyHash` for types that have `Hash` for backwards compatibility.
-impl LegacyHashForHash<
-    T, impl THash: Hash<T, pedersen::HashState, pedersen::HashStateImpl>
-> of LegacyHash<T> {
+impl LegacyHashForHash<T, +Hash<T, core::pedersen::HashState>> of LegacyHash<T> {
     #[inline(always)]
     fn hash(state: felt252, value: T) -> felt252 {
-        THash::update_state(pedersen::HashState { state }, value).state
+        core::pedersen::HashState { state }.update_with(value).state
     }
 }
 
 /// Extension trait for hash state accumulators.
-trait HashStateExTrait<S, T> {
+pub trait HashStateExTrait<S, T> {
     /// Updates the hash state with the given value.
+    #[must_use]
     fn update_with(self: S, value: T) -> S;
 }
 
-impl HashStateEx<
-    S, impl SHashState: HashStateTrait<S>, T, impl THash: Hash<T, S, SHashState>
-> of HashStateExTrait<S, T> {
+impl HashStateEx<S, +HashStateTrait<S>, T, +Hash<T, S>> of HashStateExTrait<S, T> {
     #[inline(always)]
     fn update_with(self: S, value: T) -> S {
-        THash::update_state(self, value)
+        Hash::update_state(self, value)
     }
 }
 
-impl HashFelt252<S, impl SHashState: HashStateTrait<S>> of Hash<felt252, S, SHashState> {
+impl HashFelt252<S, +HashStateTrait<S>> of Hash<felt252, S> {
     #[inline(always)]
     fn update_state(state: S, value: felt252) -> S {
         state.update(value)
     }
 }
 
-impl HashBool<
-    S, impl SHashState: HashStateTrait<S>, impl SDrop: Drop<S>
-> of Hash<bool, S, SHashState> {
-    #[inline(always)]
-    fn update_state(state: S, value: bool) -> S {
-        state.update(value.into())
-    }
-}
-
-impl HashU8<S, impl SHashState: HashStateTrait<S>, impl SDrop: Drop<S>> of Hash<u8, S, SHashState> {
-    #[inline(always)]
-    fn update_state(state: S, value: u8) -> S {
-        state.update(value.into())
-    }
-}
-
-impl HashU16<
-    S, impl SHashState: HashStateTrait<S>, impl SDrop: Drop<S>
-> of Hash<u16, S, SHashState> {
-    #[inline(always)]
-    fn update_state(state: S, value: u16) -> S {
-        state.update(value.into())
+/// Impl for `Hash` for types that can be converted into `felt252` using the `Into` trait.
+/// Usage example:
+/// ```ignore
+/// impl MyTypeHash<S, +HashStateTrait<S>, +Drop<S>> =
+///     core::hash::into_felt252_based::HashImpl<MyType, S>;`
+/// ```
+pub mod into_felt252_based {
+    pub impl HashImpl<
+        T, S, +Into<T, felt252>, +super::HashStateTrait<S>, +Drop<S>
+    > of super::Hash<T, S> {
+        #[inline(always)]
+        fn update_state(state: S, value: T) -> S {
+            state.update(value.into())
+        }
     }
 }
 
-impl HashU32<
-    S, impl SHashState: HashStateTrait<S>, impl SDrop: Drop<S>
-> of Hash<u32, S, SHashState> {
-    #[inline(always)]
-    fn update_state(state: S, value: u32) -> S {
-        state.update(value.into())
-    }
-}
+impl HashBool<S, +HashStateTrait<S>, +Drop<S>> = into_felt252_based::HashImpl<bool, S>;
+impl HashU8<S, +HashStateTrait<S>, +Drop<S>> = into_felt252_based::HashImpl<u8, S>;
+impl HashU16<S, +HashStateTrait<S>, +Drop<S>> = into_felt252_based::HashImpl<u16, S>;
+impl HashU32<S, +HashStateTrait<S>, +Drop<S>> = into_felt252_based::HashImpl<u32, S>;
+impl HashU64<S, +HashStateTrait<S>, +Drop<S>> = into_felt252_based::HashImpl<u64, S>;
+impl HashU128<S, +HashStateTrait<S>, +Drop<S>> = into_felt252_based::HashImpl<u128, S>;
+impl HashI8<S, +HashStateTrait<S>, +Drop<S>> = into_felt252_based::HashImpl<i8, S>;
+impl HashI16<S, +HashStateTrait<S>, +Drop<S>> = into_felt252_based::HashImpl<i16, S>;
+impl HashI32<S, +HashStateTrait<S>, +Drop<S>> = into_felt252_based::HashImpl<i32, S>;
+impl HashI64<S, +HashStateTrait<S>, +Drop<S>> = into_felt252_based::HashImpl<i64, S>;
+impl HashI128<S, +HashStateTrait<S>, +Drop<S>> = into_felt252_based::HashImpl<i128, S>;
 
-impl HashU64<
-    S, impl SHashState: HashStateTrait<S>, impl SDrop: Drop<S>
-> of Hash<u64, S, SHashState> {
-    #[inline(always)]
-    fn update_state(state: S, value: u64) -> S {
-        state.update(value.into())
-    }
-}
-
-impl HashU128<
-    S, impl SHashState: HashStateTrait<S>, impl SDrop: Drop<S>
-> of Hash<u128, S, SHashState> {
-    #[inline(always)]
-    fn update_state(state: S, value: u128) -> S {
-        state.update(value.into())
-    }
-}
-
-impl HashContractAddress<
-    S, impl SHashState: HashStateTrait<S>, impl SDrop: Drop<S>
-> of Hash<starknet::ContractAddress, S, SHashState> {
-    #[inline(always)]
-    fn update_state(state: S, value: ContractAddress) -> S {
-        state.update(value.into())
-    }
-}
-
-impl TupleSize0Hash<S, impl SHashState: HashStateTrait<S>> of Hash<(), S, SHashState> {
+impl TupleSize0Hash<S, +HashStateTrait<S>> of Hash<(), S> {
     #[inline(always)]
     fn update_state(state: S, value: ()) -> S {
         state
     }
 }
 
-impl TupleSize1Hash<
-    E0, S, impl E0Hash: Hash<E0, S, SHashState>, impl SHashState: HashStateTrait<S>
-> of Hash<(E0,), S, SHashState> {
+impl TupleSize1Hash<E0, S, +Hash<E0, S>, +HashStateTrait<S>> of Hash<(E0,), S> {
     #[inline(always)]
     fn update_state(state: S, value: (E0,)) -> S {
         let (e0,) = value;
@@ -131,15 +97,8 @@ impl TupleSize1Hash<
 }
 
 impl TupleSize2Hash<
-    E0,
-    E1,
-    S,
-    impl SHashState: HashStateTrait<S>,
-    impl E0Hash: Hash<E0, S, SHashState>,
-    impl E1Hash: Hash<E1, S, SHashState>,
-    impl E0Drop: Drop<E0>,
-    impl E1Drop: Drop<E1>,
-> of Hash<(E0, E1), S, SHashState> {
+    E0, E1, S, +HashStateTrait<S>, +Hash<E0, S>, +Hash<E1, S>, +Drop<E0>, +Drop<E1>,
+> of Hash<(E0, E1), S> {
     #[inline(always)]
     fn update_state(state: S, value: (E0, E1,)) -> S {
         let (e0, e1) = value;
@@ -152,14 +111,14 @@ impl TupleSize3Hash<
     E1,
     E2,
     S,
-    impl SHashState: HashStateTrait<S>,
-    impl E0Hash: Hash<E0, S, SHashState>,
-    impl E1Hash: Hash<E1, S, SHashState>,
-    impl E2Hash: Hash<E2, S, SHashState>,
-    impl E0Drop: Drop<E0>,
-    impl E1Drop: Drop<E1>,
-    impl E2Drop: Drop<E2>,
-> of Hash<(E0, E1, E2), S, SHashState> {
+    +HashStateTrait<S>,
+    +Hash<E0, S>,
+    +Hash<E1, S>,
+    +Hash<E2, S>,
+    +Drop<E0>,
+    +Drop<E1>,
+    +Drop<E2>,
+> of Hash<(E0, E1, E2), S> {
     #[inline(always)]
     fn update_state(state: S, value: (E0, E1, E2)) -> S {
         let (e0, e1, e2) = value;
@@ -173,16 +132,16 @@ impl TupleSize4Hash<
     E2,
     E3,
     S,
-    impl SHashState: HashStateTrait<S>,
-    impl E0Hash: Hash<E0, S, SHashState>,
-    impl E1Hash: Hash<E1, S, SHashState>,
-    impl E2Hash: Hash<E2, S, SHashState>,
-    impl E3Hash: Hash<E3, S, SHashState>,
-    impl E0Drop: Drop<E0>,
-    impl E1Drop: Drop<E1>,
-    impl E2Drop: Drop<E2>,
-    impl E3Drop: Drop<E3>,
-> of Hash<(E0, E1, E2, E3), S, SHashState> {
+    +HashStateTrait<S>,
+    +Hash<E0, S>,
+    +Hash<E1, S>,
+    +Hash<E2, S>,
+    +Hash<E3, S>,
+    +Drop<E0>,
+    +Drop<E1>,
+    +Drop<E2>,
+    +Drop<E3>,
+> of Hash<(E0, E1, E2, E3), S> {
     #[inline(always)]
     fn update_state(state: S, value: (E0, E1, E2, E3)) -> S {
         let (e0, e1, e2, e3) = value;
diff --git a/corelib/src/integer.cairo b/corelib/src/integer.cairo
index 27681b4..d813425 100644
--- a/corelib/src/integer.cairo
+++ b/corelib/src/integer.cairo
@@ -1,28 +1,19 @@
-use option::OptionTrait;
-use result::ResultTrait;
-use traits::{Into, TryInto, Default, Felt252DictValue};
-use zeroable::{IsZeroResult, NonZeroIntoImpl, Zeroable};
-use serde::Serde;
-use array::ArrayTrait;
-use array::SpanTrait;
+use core::option::OptionTrait;
+use core::result::ResultTrait;
+use core::traits::{Into, TryInto, Default, Felt252DictValue};
+use core::zeroable::{IsZeroResult, NonZeroIntoImpl, Zeroable};
+use core::array::ArrayTrait;
+use core::array::SpanTrait;
 
 // TODO(spapini): Add method for const creation from Integer.
-trait NumericLiteral<T>;
+pub trait NumericLiteral<T>;
 impl NumericLiteralfelt252 of NumericLiteral<felt252>;
 
 #[derive(Copy, Drop)]
-extern type u128;
+pub extern type u128;
 impl NumericLiteralu128 of NumericLiteral<u128>;
-extern fn u128_const<value>() -> u128 nopanic;
 
-impl U128Serde of Serde<u128> {
-    fn serialize(self: @u128, ref output: Array<felt252>) {
-        Into::<u128, felt252>::into(*self).serialize(ref output);
-    }
-    fn deserialize(ref serialized: Span<felt252>) -> Option<u128> {
-        Option::Some(((*serialized.pop_front()?).try_into())?)
-    }
-}
+impl U128Serde = core::serde::into_felt252_based::SerdeImpl<u128>;
 
 enum U128sFromFelt252Result {
     Narrow: u128,
@@ -34,11 +25,11 @@ extern fn u128s_from_felt252(a: felt252) -> U128sFromFelt252Result implicits(Ran
 fn u128_try_from_felt252(a: felt252) -> Option<u128> implicits(RangeCheck) nopanic {
     match u128s_from_felt252(a) {
         U128sFromFelt252Result::Narrow(x) => Option::Some(x),
-        U128sFromFelt252Result::Wide(x) => Option::None,
+        U128sFromFelt252Result::Wide(_x) => Option::None,
     }
 }
 
-extern fn u128_to_felt252(a: u128) -> felt252 nopanic;
+pub(crate) extern fn u128_to_felt252(a: u128) -> felt252 nopanic;
 
 extern fn u128_overflowing_add(
     lhs: u128, rhs: u128
@@ -54,7 +45,7 @@ fn u128_wrapping_add(lhs: u128, rhs: u128) -> u128 implicits(RangeCheck) nopanic
     }
 }
 
-fn u128_wrapping_sub(a: u128, b: u128) -> u128 implicits(RangeCheck) nopanic {
+pub fn u128_wrapping_sub(a: u128, b: u128) -> u128 implicits(RangeCheck) nopanic {
     match u128_overflowing_sub(a, b) {
         Result::Ok(x) => x,
         Result::Err(x) => x,
@@ -65,7 +56,7 @@ fn u128_wrapping_sub(a: u128, b: u128) -> u128 implicits(RangeCheck) nopanic {
 ///
 /// The guarantee is verified by `u128_mul_guarantee_verify`, which is the only way to destruct this
 /// type. This way, one can trust that the guarantee holds although it has not yet been verified.
-extern type U128MulGuarantee;
+pub extern type U128MulGuarantee;
 
 /// Multiplies two u128s and returns a `U128MulGuarantee` for the result of `a * b`.
 extern fn u128_guarantee_mul(a: u128, b: u128) -> (u128, u128, U128MulGuarantee) nopanic;
@@ -75,7 +66,7 @@ extern fn u128_mul_guarantee_verify(guarantee: U128MulGuarantee) implicits(Range
 
 /// Multiplies two u128s and returns `(high, low)` - the 128-bit parts of the result.
 #[inline(always)]
-fn u128_wide_mul(a: u128, b: u128) -> (u128, u128) nopanic {
+pub fn u128_wide_mul(a: u128, b: u128) -> (u128, u128) nopanic {
     let (high, low, _) = u128_guarantee_mul(a, b);
     (high, low)
 }
@@ -86,7 +77,7 @@ impl U128MulGuaranteeDestruct of Destruct<U128MulGuarantee> {
     }
 }
 
-extern fn u128_sqrt(value: u128) -> u64 implicits(RangeCheck) nopanic;
+pub extern fn u128_sqrt(value: u128) -> u64 implicits(RangeCheck) nopanic;
 
 fn u128_overflowing_mul(lhs: u128, rhs: u128) -> (u128, bool) implicits(RangeCheck) nopanic {
     let (top_word, bottom_word) = u128_wide_mul(lhs, rhs);
@@ -100,7 +91,7 @@ fn u128_overflowing_mul(lhs: u128, rhs: u128) -> (u128, bool) implicits(RangeChe
 fn u128_checked_add(lhs: u128, rhs: u128) -> Option<u128> implicits(RangeCheck) nopanic {
     match u128_overflowing_add(lhs, rhs) {
         Result::Ok(r) => Option::Some(r),
-        Result::Err(r) => Option::None,
+        Result::Err(_r) => Option::None,
     }
 }
 
@@ -120,7 +111,7 @@ impl U128AddEq of AddEq<u128> {
 fn u128_checked_sub(lhs: u128, rhs: u128) -> Option<u128> implicits(RangeCheck) nopanic {
     match u128_overflowing_sub(lhs, rhs) {
         Result::Ok(r) => Option::Some(r),
-        Result::Err(r) => Option::None,
+        Result::Err(_r) => Option::None,
     }
 }
 
@@ -164,7 +155,7 @@ fn u128_try_as_non_zero(a: u128) -> Option<NonZero<u128>> nopanic {
     }
 }
 
-impl U128TryIntoNonZero of TryInto<u128, NonZero<u128>> {
+pub(crate) impl U128TryIntoNonZero of TryInto<u128, NonZero<u128>> {
     fn try_into(self: u128) -> Option<NonZero<u128>> {
         Option::Some(u128_as_non_zero(self))
     }
@@ -172,7 +163,7 @@ impl U128TryIntoNonZero of TryInto<u128, NonZero<u128>> {
 
 impl U128Div of Div<u128> {
     fn div(lhs: u128, rhs: u128) -> u128 {
-        let (q, r) = u128_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
+        let (q, _r) = u128_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
         q
     }
 }
@@ -185,7 +176,7 @@ impl U128DivEq of DivEq<u128> {
 
 impl U128Rem of Rem<u128> {
     fn rem(lhs: u128, rhs: u128) -> u128 {
-        let (q, r) = u128_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
+        let (_q, r) = u128_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
         r
     }
 }
@@ -202,7 +193,7 @@ impl U128DivRem of DivRem<u128> {
     }
 }
 
-extern fn u128_safe_divmod(
+pub extern fn u128_safe_divmod(
     lhs: u128, rhs: NonZero<u128>
 ) -> (u128, u128) implicits(RangeCheck) nopanic;
 
@@ -238,7 +229,7 @@ impl U128PartialOrd of PartialOrd<u128> {
     }
 }
 
-extern type Bitwise;
+pub extern type Bitwise;
 extern fn bitwise(lhs: u128, rhs: u128) -> (u128, u128, u128) implicits(Bitwise) nopanic;
 impl U128BitAnd of BitAnd<u128> {
     #[inline(always)]
@@ -267,14 +258,19 @@ impl U128BitNot of BitNot<u128> {
     }
 }
 
-extern fn u128_is_zero(a: u128) -> IsZeroResult<u128> implicits() nopanic;
+impl U128BitSize of core::num::traits::BitSize<u128> {
+    fn bits() -> usize {
+        128
+    }
+}
+
+pub(crate) extern fn u128_is_zero(a: u128) -> IsZeroResult<u128> implicits() nopanic;
 
-extern fn u128_byte_reverse(input: u128) -> u128 implicits(Bitwise) nopanic;
+pub extern fn u128_byte_reverse(input: u128) -> u128 implicits(Bitwise) nopanic;
 
 #[derive(Copy, Drop)]
-extern type u8;
+pub extern type u8;
 impl NumericLiteralu8 of NumericLiteral<u8>;
-extern fn u8_const<value>() -> u8 nopanic;
 extern fn u8_to_felt252(a: u8) -> felt252 nopanic;
 
 #[panic_with('u8_from Overflow', u8_from_felt252)]
@@ -282,14 +278,7 @@ extern fn u8_try_from_felt252(a: felt252) -> Option<u8> implicits(RangeCheck) no
 
 extern fn u8_eq(lhs: u8, rhs: u8) -> bool implicits() nopanic;
 
-impl U8Serde of Serde<u8> {
-    fn serialize(self: @u8, ref output: Array<felt252>) {
-        Into::<u8, felt252>::into(*self).serialize(ref output);
-    }
-    fn deserialize(ref serialized: Span<felt252>) -> Option<u8> {
-        Option::Some(((*serialized.pop_front()?).try_into())?)
-    }
-}
+impl U8Serde = core::serde::into_felt252_based::SerdeImpl<u8>;
 
 impl U8PartialEq of PartialEq<u8> {
     #[inline(always)]
@@ -321,17 +310,19 @@ impl U8PartialOrd of PartialOrd<u8> {
     }
 }
 
-extern fn u8_overflowing_add(lhs: u8, rhs: u8) -> Result<u8, u8> implicits(RangeCheck) nopanic;
+pub(crate) extern fn u8_overflowing_add(
+    lhs: u8, rhs: u8
+) -> Result<u8, u8> implicits(RangeCheck) nopanic;
 extern fn u8_overflowing_sub(lhs: u8, rhs: u8) -> Result<u8, u8> implicits(RangeCheck) nopanic;
 
-fn u8_wrapping_add(lhs: u8, rhs: u8) -> u8 implicits(RangeCheck) nopanic {
+pub fn u8_wrapping_add(lhs: u8, rhs: u8) -> u8 implicits(RangeCheck) nopanic {
     match u8_overflowing_add(lhs, rhs) {
         Result::Ok(x) => x,
         Result::Err(x) => x,
     }
 }
 
-fn u8_wrapping_sub(lhs: u8, rhs: u8) -> u8 implicits(RangeCheck) nopanic {
+pub fn u8_wrapping_sub(lhs: u8, rhs: u8) -> u8 implicits(RangeCheck) nopanic {
     match u8_overflowing_sub(lhs, rhs) {
         Result::Ok(x) => x,
         Result::Err(x) => x,
@@ -341,7 +332,7 @@ fn u8_wrapping_sub(lhs: u8, rhs: u8) -> u8 implicits(RangeCheck) nopanic {
 fn u8_checked_add(lhs: u8, rhs: u8) -> Option<u8> implicits(RangeCheck) nopanic {
     match u8_overflowing_add(lhs, rhs) {
         Result::Ok(r) => Option::Some(r),
-        Result::Err(r) => Option::None,
+        Result::Err(_r) => Option::None,
     }
 }
 
@@ -360,7 +351,7 @@ impl U8AddEq of AddEq<u8> {
 fn u8_checked_sub(lhs: u8, rhs: u8) -> Option<u8> implicits(RangeCheck) nopanic {
     match u8_overflowing_sub(lhs, rhs) {
         Result::Ok(r) => Option::Some(r),
-        Result::Err(r) => Option::None,
+        Result::Err(_r) => Option::None,
     }
 }
 
@@ -376,8 +367,8 @@ impl U8SubEq of SubEq<u8> {
     }
 }
 
-extern fn u8_wide_mul(lhs: u8, rhs: u8) -> u16 implicits() nopanic;
-extern fn u8_sqrt(value: u8) -> u8 implicits(RangeCheck) nopanic;
+pub extern fn u8_wide_mul(lhs: u8, rhs: u8) -> u16 implicits() nopanic;
+pub extern fn u8_sqrt(value: u8) -> u8 implicits(RangeCheck) nopanic;
 
 impl U8Mul of Mul<u8> {
     fn mul(lhs: u8, rhs: u8) -> u8 {
@@ -392,7 +383,7 @@ impl U8MulEq of MulEq<u8> {
 }
 
 extern fn u8_is_zero(a: u8) -> IsZeroResult<u8> implicits() nopanic;
-extern fn u8_safe_divmod(lhs: u8, rhs: NonZero<u8>) -> (u8, u8) implicits(RangeCheck) nopanic;
+pub extern fn u8_safe_divmod(lhs: u8, rhs: NonZero<u8>) -> (u8, u8) implicits(RangeCheck) nopanic;
 
 #[panic_with('u8 is 0', u8_as_non_zero)]
 fn u8_try_as_non_zero(a: u8) -> Option<NonZero<u8>> nopanic {
@@ -410,7 +401,7 @@ impl U8TryIntoNonZero of TryInto<u8, NonZero<u8>> {
 
 impl U8Div of Div<u8> {
     fn div(lhs: u8, rhs: u8) -> u8 {
-        let (q, r) = u8_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
+        let (q, _r) = u8_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
         q
     }
 }
@@ -423,7 +414,7 @@ impl U8DivEq of DivEq<u8> {
 
 impl U8Rem of Rem<u8> {
     fn rem(lhs: u8, rhs: u8) -> u8 {
-        let (q, r) = u8_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
+        let (_q, r) = u8_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
         r
     }
 }
@@ -468,10 +459,15 @@ impl U8BitOr of BitOr<u8> {
     }
 }
 
+impl U8BitSize of core::num::traits::BitSize<u8> {
+    fn bits() -> usize {
+        8
+    }
+}
+
 #[derive(Copy, Drop)]
-extern type u16;
+pub extern type u16;
 impl NumericLiteralu16 of NumericLiteral<u16>;
-extern fn u16_const<value>() -> u16 nopanic;
 extern fn u16_to_felt252(a: u16) -> felt252 nopanic;
 
 #[panic_with('u16_from Overflow', u16_from_felt252)]
@@ -479,14 +475,7 @@ extern fn u16_try_from_felt252(a: felt252) -> Option<u16> implicits(RangeCheck)
 
 extern fn u16_eq(lhs: u16, rhs: u16) -> bool implicits() nopanic;
 
-impl U16Serde of Serde<u16> {
-    fn serialize(self: @u16, ref output: Array<felt252>) {
-        Into::<u16, felt252>::into(*self).serialize(ref output);
-    }
-    fn deserialize(ref serialized: Span<felt252>) -> Option<u16> {
-        Option::Some(((*serialized.pop_front()?).try_into())?)
-    }
-}
+impl U16Serde = core::serde::into_felt252_based::SerdeImpl<u16>;
 
 impl U16PartialEq of PartialEq<u16> {
     #[inline(always)]
@@ -528,7 +517,7 @@ fn u16_wrapping_add(lhs: u16, rhs: u16) -> u16 implicits(RangeCheck) nopanic {
     }
 }
 
-fn u16_wrapping_sub(lhs: u16, rhs: u16) -> u16 implicits(RangeCheck) nopanic {
+pub fn u16_wrapping_sub(lhs: u16, rhs: u16) -> u16 implicits(RangeCheck) nopanic {
     match u16_overflowing_sub(lhs, rhs) {
         Result::Ok(x) => x,
         Result::Err(x) => x,
@@ -538,7 +527,7 @@ fn u16_wrapping_sub(lhs: u16, rhs: u16) -> u16 implicits(RangeCheck) nopanic {
 fn u16_checked_add(lhs: u16, rhs: u16) -> Option<u16> implicits(RangeCheck) nopanic {
     match u16_overflowing_add(lhs, rhs) {
         Result::Ok(r) => Option::Some(r),
-        Result::Err(r) => Option::None,
+        Result::Err(_r) => Option::None,
     }
 }
 
@@ -557,7 +546,7 @@ impl U16AddEq of AddEq<u16> {
 fn u16_checked_sub(lhs: u16, rhs: u16) -> Option<u16> implicits(RangeCheck) nopanic {
     match u16_overflowing_sub(lhs, rhs) {
         Result::Ok(r) => Option::Some(r),
-        Result::Err(r) => Option::None,
+        Result::Err(_r) => Option::None,
     }
 }
 
@@ -573,8 +562,8 @@ impl U16SubEq of SubEq<u16> {
     }
 }
 
-extern fn u16_wide_mul(lhs: u16, rhs: u16) -> u32 implicits() nopanic;
-extern fn u16_sqrt(value: u16) -> u8 implicits(RangeCheck) nopanic;
+pub extern fn u16_wide_mul(lhs: u16, rhs: u16) -> u32 implicits() nopanic;
+pub extern fn u16_sqrt(value: u16) -> u8 implicits(RangeCheck) nopanic;
 
 impl U16Mul of Mul<u16> {
     fn mul(lhs: u16, rhs: u16) -> u16 {
@@ -589,7 +578,9 @@ impl U16MulEq of MulEq<u16> {
 }
 
 extern fn u16_is_zero(a: u16) -> IsZeroResult<u16> implicits() nopanic;
-extern fn u16_safe_divmod(lhs: u16, rhs: NonZero<u16>) -> (u16, u16) implicits(RangeCheck) nopanic;
+pub extern fn u16_safe_divmod(
+    lhs: u16, rhs: NonZero<u16>
+) -> (u16, u16) implicits(RangeCheck) nopanic;
 
 #[panic_with('u16 is 0', u16_as_non_zero)]
 fn u16_try_as_non_zero(a: u16) -> Option<NonZero<u16>> nopanic {
@@ -607,7 +598,7 @@ impl U16TryIntoNonZero of TryInto<u16, NonZero<u16>> {
 
 impl U16Div of Div<u16> {
     fn div(lhs: u16, rhs: u16) -> u16 {
-        let (q, r) = u16_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
+        let (q, _r) = u16_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
         q
     }
 }
@@ -620,7 +611,7 @@ impl U16DivEq of DivEq<u16> {
 
 impl U16Rem of Rem<u16> {
     fn rem(lhs: u16, rhs: u16) -> u16 {
-        let (q, r) = u16_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
+        let (_q, r) = u16_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
         r
     }
 }
@@ -665,10 +656,15 @@ impl U16BitOr of BitOr<u16> {
     }
 }
 
+impl U16BitSize of core::num::traits::BitSize<u16> {
+    fn bits() -> usize {
+        16
+    }
+}
+
 #[derive(Copy, Drop)]
-extern type u32;
+pub extern type u32;
 impl NumericLiteralu32 of NumericLiteral<u32>;
-extern fn u32_const<value>() -> u32 nopanic;
 extern fn u32_to_felt252(a: u32) -> felt252 nopanic;
 
 #[panic_with('u32_from Overflow', u32_from_felt252)]
@@ -676,14 +672,7 @@ extern fn u32_try_from_felt252(a: felt252) -> Option<u32> implicits(RangeCheck)
 
 extern fn u32_eq(lhs: u32, rhs: u32) -> bool implicits() nopanic;
 
-impl U32Serde of Serde<u32> {
-    fn serialize(self: @u32, ref output: Array<felt252>) {
-        Into::<u32, felt252>::into(*self).serialize(ref output);
-    }
-    fn deserialize(ref serialized: Span<felt252>) -> Option<u32> {
-        Option::Some(((*serialized.pop_front()?).try_into())?)
-    }
-}
+impl U32Serde = core::serde::into_felt252_based::SerdeImpl<u32>;
 
 impl U32PartialEq of PartialEq<u32> {
     #[inline(always)]
@@ -725,7 +714,7 @@ fn u32_wrapping_add(lhs: u32, rhs: u32) -> u32 implicits(RangeCheck) nopanic {
     }
 }
 
-fn u32_wrapping_sub(lhs: u32, rhs: u32) -> u32 implicits(RangeCheck) nopanic {
+pub fn u32_wrapping_sub(lhs: u32, rhs: u32) -> u32 implicits(RangeCheck) nopanic {
     match u32_overflowing_sub(lhs, rhs) {
         Result::Ok(x) => x,
         Result::Err(x) => x,
@@ -735,7 +724,7 @@ fn u32_wrapping_sub(lhs: u32, rhs: u32) -> u32 implicits(RangeCheck) nopanic {
 fn u32_checked_add(lhs: u32, rhs: u32) -> Option<u32> implicits(RangeCheck) nopanic {
     match u32_overflowing_add(lhs, rhs) {
         Result::Ok(r) => Option::Some(r),
-        Result::Err(r) => Option::None,
+        Result::Err(_r) => Option::None,
     }
 }
 
@@ -754,7 +743,7 @@ impl U32AddEq of AddEq<u32> {
 fn u32_checked_sub(lhs: u32, rhs: u32) -> Option<u32> implicits(RangeCheck) nopanic {
     match u32_overflowing_sub(lhs, rhs) {
         Result::Ok(r) => Option::Some(r),
-        Result::Err(r) => Option::None,
+        Result::Err(_r) => Option::None,
     }
 }
 
@@ -770,8 +759,8 @@ impl U32SubEq of SubEq<u32> {
     }
 }
 
-extern fn u32_wide_mul(lhs: u32, rhs: u32) -> u64 implicits() nopanic;
-extern fn u32_sqrt(value: u32) -> u16 implicits(RangeCheck) nopanic;
+pub extern fn u32_wide_mul(lhs: u32, rhs: u32) -> u64 implicits() nopanic;
+pub extern fn u32_sqrt(value: u32) -> u16 implicits(RangeCheck) nopanic;
 
 impl U32Mul of Mul<u32> {
     fn mul(lhs: u32, rhs: u32) -> u32 {
@@ -786,7 +775,9 @@ impl U32MulEq of MulEq<u32> {
 }
 
 extern fn u32_is_zero(a: u32) -> IsZeroResult<u32> implicits() nopanic;
-extern fn u32_safe_divmod(lhs: u32, rhs: NonZero<u32>) -> (u32, u32) implicits(RangeCheck) nopanic;
+pub extern fn u32_safe_divmod(
+    lhs: u32, rhs: NonZero<u32>
+) -> (u32, u32) implicits(RangeCheck) nopanic;
 
 #[panic_with('u32 is 0', u32_as_non_zero)]
 fn u32_try_as_non_zero(a: u32) -> Option<NonZero<u32>> nopanic {
@@ -796,7 +787,7 @@ fn u32_try_as_non_zero(a: u32) -> Option<NonZero<u32>> nopanic {
     }
 }
 
-impl U32TryIntoNonZero of TryInto<u32, NonZero<u32>> {
+pub(crate) impl U32TryIntoNonZero of TryInto<u32, NonZero<u32>> {
     fn try_into(self: u32) -> Option<NonZero<u32>> {
         Option::Some(u32_as_non_zero(self))
     }
@@ -804,7 +795,7 @@ impl U32TryIntoNonZero of TryInto<u32, NonZero<u32>> {
 
 impl U32Div of Div<u32> {
     fn div(lhs: u32, rhs: u32) -> u32 {
-        let (q, r) = u32_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
+        let (q, _r) = u32_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
         q
     }
 }
@@ -817,7 +808,7 @@ impl U32DivEq of DivEq<u32> {
 
 impl U32Rem of Rem<u32> {
     fn rem(lhs: u32, rhs: u32) -> u32 {
-        let (q, r) = u32_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
+        let (_q, r) = u32_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
         r
     }
 }
@@ -862,10 +853,15 @@ impl U32BitOr of BitOr<u32> {
     }
 }
 
+impl U32BitSize of core::num::traits::BitSize<u32> {
+    fn bits() -> usize {
+        32
+    }
+}
+
 #[derive(Copy, Drop)]
-extern type u64;
+pub extern type u64;
 impl NumericLiteralu64 of NumericLiteral<u64>;
-extern fn u64_const<value>() -> u64 nopanic;
 extern fn u64_to_felt252(a: u64) -> felt252 nopanic;
 
 #[panic_with('u64_from Overflow', u64_from_felt252)]
@@ -873,14 +869,7 @@ extern fn u64_try_from_felt252(a: felt252) -> Option<u64> implicits(RangeCheck)
 
 extern fn u64_eq(lhs: u64, rhs: u64) -> bool implicits() nopanic;
 
-impl U64Serde of Serde<u64> {
-    fn serialize(self: @u64, ref output: Array<felt252>) {
-        Into::<u64, felt252>::into(*self).serialize(ref output);
-    }
-    fn deserialize(ref serialized: Span<felt252>) -> Option<u64> {
-        Option::Some(((*serialized.pop_front()?).try_into())?)
-    }
-}
+impl U64Serde = core::serde::into_felt252_based::SerdeImpl<u64>;
 
 impl U64PartialEq of PartialEq<u64> {
     #[inline(always)]
@@ -922,7 +911,7 @@ fn u64_wrapping_add(lhs: u64, rhs: u64) -> u64 implicits(RangeCheck) nopanic {
     }
 }
 
-fn u64_wrapping_sub(lhs: u64, rhs: u64) -> u64 implicits(RangeCheck) nopanic {
+pub fn u64_wrapping_sub(lhs: u64, rhs: u64) -> u64 implicits(RangeCheck) nopanic {
     match u64_overflowing_sub(lhs, rhs) {
         Result::Ok(x) => x,
         Result::Err(x) => x,
@@ -932,7 +921,7 @@ fn u64_wrapping_sub(lhs: u64, rhs: u64) -> u64 implicits(RangeCheck) nopanic {
 fn u64_checked_add(lhs: u64, rhs: u64) -> Option<u64> implicits(RangeCheck) nopanic {
     match u64_overflowing_add(lhs, rhs) {
         Result::Ok(r) => Option::Some(r),
-        Result::Err(r) => Option::None,
+        Result::Err(_r) => Option::None,
     }
 }
 
@@ -951,7 +940,7 @@ impl U64AddEq of AddEq<u64> {
 fn u64_checked_sub(lhs: u64, rhs: u64) -> Option<u64> implicits(RangeCheck) nopanic {
     match u64_overflowing_sub(lhs, rhs) {
         Result::Ok(r) => Option::Some(r),
-        Result::Err(r) => Option::None,
+        Result::Err(_r) => Option::None,
     }
 }
 
@@ -967,8 +956,8 @@ impl U64SubEq of SubEq<u64> {
     }
 }
 
-extern fn u64_wide_mul(lhs: u64, rhs: u64) -> u128 implicits() nopanic;
-extern fn u64_sqrt(value: u64) -> u32 implicits(RangeCheck) nopanic;
+pub extern fn u64_wide_mul(lhs: u64, rhs: u64) -> u128 implicits() nopanic;
+pub extern fn u64_sqrt(value: u64) -> u32 implicits(RangeCheck) nopanic;
 
 impl U64Mul of Mul<u64> {
     fn mul(lhs: u64, rhs: u64) -> u64 {
@@ -983,7 +972,9 @@ impl U64MulEq of MulEq<u64> {
 }
 
 extern fn u64_is_zero(a: u64) -> IsZeroResult<u64> implicits() nopanic;
-extern fn u64_safe_divmod(lhs: u64, rhs: NonZero<u64>) -> (u64, u64) implicits(RangeCheck) nopanic;
+pub extern fn u64_safe_divmod(
+    lhs: u64, rhs: NonZero<u64>
+) -> (u64, u64) implicits(RangeCheck) nopanic;
 
 #[panic_with('u64 is 0', u64_as_non_zero)]
 fn u64_try_as_non_zero(a: u64) -> Option<NonZero<u64>> nopanic {
@@ -1001,7 +992,7 @@ impl U64TryIntoNonZero of TryInto<u64, NonZero<u64>> {
 
 impl U64Div of Div<u64> {
     fn div(lhs: u64, rhs: u64) -> u64 {
-        let (q, r) = u64_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
+        let (q, _r) = u64_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
         q
     }
 }
@@ -1014,7 +1005,7 @@ impl U64DivEq of DivEq<u64> {
 
 impl U64Rem of Rem<u64> {
     fn rem(lhs: u64, rhs: u64) -> u64 {
-        let (q, r) = u64_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
+        let (_q, r) = u64_safe_divmod(lhs, rhs.try_into().expect('Division by 0'));
         r
     }
 }
@@ -1059,10 +1050,16 @@ impl U64BitOr of BitOr<u64> {
     }
 }
 
+impl U64BitSize of core::num::traits::BitSize<u64> {
+    fn bits() -> usize {
+        64
+    }
+}
+
 #[derive(Copy, Drop, Hash, PartialEq, Serde, starknet::Store)]
-struct u256 {
-    low: u128,
-    high: u128,
+pub struct u256 {
+    pub low: u128,
+    pub high: u128,
 }
 impl NumericLiteralU256 of NumericLiteral<u256>;
 
@@ -1246,7 +1243,7 @@ fn u256_safe_div_rem(lhs: u256, rhs: NonZero<u256>) -> (u256, u256) implicits(Ra
     let (q, r, _) = u256_safe_divmod(lhs, rhs);
     (q, r)
 }
-extern fn u256_sqrt(a: u256) -> u128 implicits(RangeCheck) nopanic;
+pub extern fn u256_sqrt(a: u256) -> u128 implicits(RangeCheck) nopanic;
 
 #[panic_with('u256 is 0', u256_as_non_zero)]
 fn u256_try_as_non_zero(a: u256) -> Option<NonZero<u256>> nopanic {
@@ -1256,7 +1253,7 @@ fn u256_try_as_non_zero(a: u256) -> Option<NonZero<u256>> nopanic {
     }
 }
 
-impl U256TryIntoNonZero of TryInto<u256, NonZero<u256>> {
+pub(crate) impl U256TryIntoNonZero of TryInto<u256, NonZero<u256>> {
     fn try_into(self: u256) -> Option<NonZero<u256>> {
         Option::Some(u256_as_non_zero(self))
     }
@@ -1264,7 +1261,7 @@ impl U256TryIntoNonZero of TryInto<u256, NonZero<u256>> {
 
 impl U256Div of Div<u256> {
     fn div(lhs: u256, rhs: u256) -> u256 {
-        let (q, r) = u256_safe_div_rem(lhs, rhs.try_into().expect('Division by 0'));
+        let (q, _r) = u256_safe_div_rem(lhs, rhs.try_into().expect('Division by 0'));
         q
     }
 }
@@ -1277,7 +1274,7 @@ impl U256DivEq of DivEq<u256> {
 
 impl U256Rem of Rem<u256> {
     fn rem(lhs: u256, rhs: u256) -> u256 {
-        let (q, r) = u256_safe_div_rem(lhs, rhs.try_into().expect('Division by 0'));
+        let (_q, r) = u256_safe_div_rem(lhs, rhs.try_into().expect('Division by 0'));
         r
     }
 }
@@ -1300,12 +1297,18 @@ impl U256BitNot of BitNot<u256> {
     }
 }
 
-#[derive(Copy, Drop, PartialEq, Serde)]
-struct u512 {
-    limb0: u128,
-    limb1: u128,
-    limb2: u128,
-    limb3: u128,
+impl U256BitSize of core::num::traits::BitSize<u256> {
+    fn bits() -> usize {
+        256
+    }
+}
+
+#[derive(Copy, Drop, Hash, PartialEq, Serde)]
+pub struct u512 {
+    pub limb0: u128,
+    pub limb1: u128,
+    pub limb2: u128,
+    pub limb3: u128,
 }
 
 // Returns the result of u128 addition, including an overflow word.
@@ -1316,7 +1319,7 @@ fn u128_add_with_carry(a: u128, b: u128) -> (u128, u128) nopanic {
     }
 }
 
-fn u256_wide_mul(a: u256, b: u256) -> u512 nopanic {
+pub fn u256_wide_mul(a: u256, b: u256) -> u512 nopanic {
     let (limb1, limb0) = u128_wide_mul(a.low, b.low);
     let (limb2, limb1_part) = u128_wide_mul(a.low, b.high);
     let (limb1, limb1_overflow0) = u128_add_with_carry(limb1, limb1_part);
@@ -1339,7 +1342,7 @@ fn u256_wide_mul(a: u256, b: u256) -> u512 nopanic {
 
 /// Calculates division with remainder of a u512 by a non-zero u256.
 #[inline(always)]
-fn u512_safe_div_rem_by_u256(
+pub fn u512_safe_div_rem_by_u256(
     lhs: u512, rhs: NonZero<u256>
 ) -> (u512, u256) implicits(RangeCheck) nopanic {
     let (q, r, _, _, _, _, _) = u512_safe_divmod_by_u256(lhs, rhs);
@@ -1361,8 +1364,10 @@ extern fn u512_safe_divmod_by_u256(
 ) implicits(RangeCheck) nopanic;
 
 /// Bounded
-trait BoundedInt<T> {
+pub trait BoundedInt<T> {
+    #[must_use]
     fn min() -> T nopanic;
+    #[must_use]
     fn max() -> T nopanic;
 }
 
@@ -1432,63 +1437,118 @@ impl BoundedU256 of BoundedInt<u256> {
     }
 }
 
+impl BoundedI8 of BoundedInt<i8> {
+    #[inline(always)]
+    fn min() -> i8 nopanic {
+        -0x80
+    }
+    #[inline(always)]
+    fn max() -> i8 nopanic {
+        0x7f
+    }
+}
+
+impl BoundedI16 of BoundedInt<i16> {
+    #[inline(always)]
+    fn min() -> i16 nopanic {
+        -0x8000
+    }
+    #[inline(always)]
+    fn max() -> i16 nopanic {
+        0x7fff
+    }
+}
+
+impl BoundedI32 of BoundedInt<i32> {
+    #[inline(always)]
+    fn min() -> i32 nopanic {
+        -0x80000000
+    }
+    #[inline(always)]
+    fn max() -> i32 nopanic {
+        0x7fffffff
+    }
+}
+
+impl BoundedI64 of BoundedInt<i64> {
+    #[inline(always)]
+    fn min() -> i64 nopanic {
+        -0x8000000000000000
+    }
+    #[inline(always)]
+    fn max() -> i64 nopanic {
+        0x7fffffffffffffff
+    }
+}
+
+impl BoundedI128 of BoundedInt<i128> {
+    #[inline(always)]
+    fn min() -> i128 nopanic {
+        -0x80000000000000000000000000000000
+    }
+    #[inline(always)]
+    fn max() -> i128 nopanic {
+        0x7fffffffffffffffffffffffffffffff
+    }
+}
+
 /// Conversions.
-impl Felt252TryIntoU8 of TryInto<felt252, u8> {
+pub(crate) impl Felt252TryIntoU8 of TryInto<felt252, u8> {
     fn try_into(self: felt252) -> Option<u8> {
         u8_try_from_felt252(self)
     }
 }
-impl U8IntoFelt252 of Into<u8, felt252> {
+pub(crate) impl U8IntoFelt252 of Into<u8, felt252> {
     fn into(self: u8) -> felt252 {
         u8_to_felt252(self)
     }
 }
-impl Felt252TryIntoU16 of TryInto<felt252, u16> {
+pub(crate) impl Felt252TryIntoU16 of TryInto<felt252, u16> {
     fn try_into(self: felt252) -> Option<u16> {
         u16_try_from_felt252(self)
     }
 }
-impl U16IntoFelt252 of Into<u16, felt252> {
+pub(crate) impl U16IntoFelt252 of Into<u16, felt252> {
     fn into(self: u16) -> felt252 {
         u16_to_felt252(self)
     }
 }
-impl Felt252TryIntoU32 of TryInto<felt252, u32> {
+pub(crate) impl Felt252TryIntoU32 of TryInto<felt252, u32> {
     fn try_into(self: felt252) -> Option<u32> {
         u32_try_from_felt252(self)
     }
 }
-impl U32IntoFelt252 of Into<u32, felt252> {
+pub(crate) impl U32IntoFelt252 of Into<u32, felt252> {
     fn into(self: u32) -> felt252 {
         u32_to_felt252(self)
     }
 }
-impl Felt252TryIntoU64 of TryInto<felt252, u64> {
+pub(crate) impl Felt252TryIntoU64 of TryInto<felt252, u64> {
     fn try_into(self: felt252) -> Option<u64> {
         u64_try_from_felt252(self)
     }
 }
-impl U64IntoFelt252 of Into<u64, felt252> {
+pub(crate) impl U64IntoFelt252 of Into<u64, felt252> {
     fn into(self: u64) -> felt252 {
         u64_to_felt252(self)
     }
 }
-impl Felt252TryIntoU128 of TryInto<felt252, u128> {
+pub(crate) impl Felt252TryIntoU128 of TryInto<felt252, u128> {
     fn try_into(self: felt252) -> Option<u128> {
         u128_try_from_felt252(self)
     }
 }
-impl U128IntoFelt252 of Into<u128, felt252> {
+pub(crate) impl U128IntoFelt252 of Into<u128, felt252> {
     fn into(self: u128) -> felt252 {
         u128_to_felt252(self)
     }
 }
-impl Felt252IntoU256 of Into<felt252, u256> {
+pub(crate) impl Felt252IntoU256 of Into<felt252, u256> {
     fn into(self: felt252) -> u256 {
         u256_from_felt252(self)
     }
 }
-impl U256TryIntoFelt252 of TryInto<u256, felt252> {
+pub(crate) impl U256TryIntoFelt252 of TryInto<u256, felt252> {
     fn try_into(self: u256) -> Option<felt252> {
         let FELT252_PRIME_HIGH = 0x8000000000000110000000000000000_u128;
         if self.high > FELT252_PRIME_HIGH {
@@ -1510,7 +1570,7 @@ impl Felt252TryIntoI8 of TryInto<felt252, i8> {
         i8_try_from_felt252(self)
     }
 }
-impl I8IntoFelt252 of Into<i8, felt252> {
+pub(crate) impl I8IntoFelt252 of Into<i8, felt252> {
     fn into(self: i8) -> felt252 {
         i8_to_felt252(self)
     }
@@ -1520,7 +1580,7 @@ impl Felt252TryIntoI16 of TryInto<felt252, i16> {
         i16_try_from_felt252(self)
     }
 }
-impl I16IntoFelt252 of Into<i16, felt252> {
+pub(crate) impl I16IntoFelt252 of Into<i16, felt252> {
     fn into(self: i16) -> felt252 {
         i16_to_felt252(self)
     }
@@ -1530,7 +1590,7 @@ impl Felt252TryIntoI32 of TryInto<felt252, i32> {
         i32_try_from_felt252(self)
     }
 }
-impl I32IntoFelt252 of Into<i32, felt252> {
+pub(crate) impl I32IntoFelt252 of Into<i32, felt252> {
     fn into(self: i32) -> felt252 {
         i32_to_felt252(self)
     }
@@ -1540,7 +1600,7 @@ impl Felt252TryIntoI64 of TryInto<felt252, i64> {
         i64_try_from_felt252(self)
     }
 }
-impl I64IntoFelt252 of Into<i64, felt252> {
+pub(crate) impl I64IntoFelt252 of Into<i64, felt252> {
     fn into(self: i64) -> felt252 {
         i64_to_felt252(self)
     }
@@ -1550,7 +1610,7 @@ impl Felt252TryIntoI128 of TryInto<felt252, i128> {
         i128_try_from_felt252(self)
     }
 }
-impl I128IntoFelt252 of Into<i128, felt252> {
+pub(crate) impl I128IntoFelt252 of Into<i128, felt252> {
     fn into(self: i128) -> felt252 {
         i128_to_felt252(self)
     }
@@ -1558,7 +1618,7 @@ impl I128IntoFelt252 of Into<i128, felt252> {
 
 // TODO(lior): Restrict the function (using traits) in the high-level compiler so that wrong types
 //   will not lead to Sierra errors.
-extern fn upcast<FromType, ToType>(x: FromType) -> ToType nopanic;
+pub(crate) extern fn upcast<FromType, ToType>(x: FromType) -> ToType nopanic;
 
 // TODO(lior): Restrict the function (using traits) in the high-level compiler so that wrong types
 //   will not lead to Sierra errors.
@@ -1567,32 +1627,50 @@ extern fn downcast<FromType, ToType>(x: FromType) -> Option<ToType> implicits(Ra
 // Marks `FromType` as upcastable to `ToType`.
 // Do not add user code implementing this trait.
 trait Upcastable<FromType, ToType>;
-impl UpcastableU8U16 of Upcastable<u8, u16> {}
-impl UpcastableU8U32 of Upcastable<u8, u32> {}
-impl UpcastableU8U64 of Upcastable<u8, u64> {}
-impl UpcastableU8U128 of Upcastable<u8, u128> {}
-impl UpcastableU16U32 of Upcastable<u16, u32> {}
-impl UpcastableU16U64 of Upcastable<u16, u64> {}
-impl UpcastableU16U128 of Upcastable<u16, u128> {}
-impl UpcastableU32U64 of Upcastable<u32, u64> {}
-impl UpcastableU32U128 of Upcastable<u32, u128> {}
-impl UpcastableU64U128 of Upcastable<u64, u128> {}
-// Marks `FromType` as downcastable to `ToType`.
+impl UpcastableU8U16 of Upcastable<u8, u16>;
+impl UpcastableU8I16 of Upcastable<u8, i16>;
+impl UpcastableU8U32 of Upcastable<u8, u32>;
+impl UpcastableU8I32 of Upcastable<u8, i32>;
+impl UpcastableU8U64 of Upcastable<u8, u64>;
+impl UpcastableU8I64 of Upcastable<u8, i64>;
+impl UpcastableU8U128 of Upcastable<u8, u128>;
+impl UpcastableU8I128 of Upcastable<u8, i128>;
+impl UpcastableI8I16 of Upcastable<i8, i16>;
+impl UpcastableI8I32 of Upcastable<i8, i32>;
+impl UpcastableI8I64 of Upcastable<i8, i64>;
+impl UpcastableI8I128 of Upcastable<i8, i128>;
+impl UpcastableU16U32 of Upcastable<u16, u32>;
+impl UpcastableU16I32 of Upcastable<u16, i32>;
+impl UpcastableU16U64 of Upcastable<u16, u64>;
+impl UpcastableU16I64 of Upcastable<u16, i64>;
+impl UpcastableU16U128 of Upcastable<u16, u128>;
+impl UpcastableU16I128 of Upcastable<u16, i128>;
+impl UpcastableI16I32 of Upcastable<i16, i32>;
+impl UpcastableI16I64 of Upcastable<i16, i64>;
+impl UpcastableI16I128 of Upcastable<i16, i128>;
+impl UpcastableU32U64 of Upcastable<u32, u64>;
+impl UpcastableU32I64 of Upcastable<u32, i64>;
+impl UpcastableU32U128 of Upcastable<u32, u128>;
+impl UpcastableU32I128 of Upcastable<u32, i128>;
+impl UpcastableI32I64 of Upcastable<i32, i64>;
+impl UpcastableI32I128 of Upcastable<i32, i128>;
+impl UpcastableU64U128 of Upcastable<u64, u128>;
+impl UpcastableU64I128 of Upcastable<u64, i128>;
+impl UpcastableI64I128 of Upcastable<i64, i128>;
+// Marks a type as an int that is downcastable to other downcastable ints.
 // Do not add user code implementing this trait.
-trait Downcastable<FromType, ToType>;
-impl DowncastableU128U64 of Downcastable<u128, u64> {}
-impl DowncastableU128U32 of Downcastable<u128, u32> {}
-impl DowncastableU128U16 of Downcastable<u128, u16> {}
-impl DowncastableU128U8 of Downcastable<u128, u8> {}
+trait DowncastableInt<T>;
+impl DowncastableU8 of DowncastableInt<u8>;
+impl DowncastableI8 of DowncastableInt<i8>;
+impl DowncastableU16 of DowncastableInt<u16>;
+impl DowncastableI16 of DowncastableInt<i16>;
+impl DowncastableU32 of DowncastableInt<u32>;
+impl DowncastableI32 of DowncastableInt<i32>;
+impl DowncastableU64 of DowncastableInt<u64>;
+impl DowncastableI64 of DowncastableInt<i64>;
+impl DowncastableU128 of DowncastableInt<u128>;
+impl DowncastableI128 of DowncastableInt<i128>;
 
-impl DowncastableU64U32 of Downcastable<u64, u32> {}
-impl DowncastableU64U16 of Downcastable<u64, u16> {}
-impl DowncastableU64U8 of Downcastable<u64, u8> {}
-
-impl DowncastableU32U16 of Downcastable<u32, u16> {}
-impl DowncastableU32U8 of Downcastable<u32, u8> {}
-
-impl DowncastableU16U8 of Downcastable<u16, u8> {}
 
 /// Default values
 impl U8Default of Default<u8> {
@@ -1674,14 +1752,14 @@ impl U128Felt252DictValue of Felt252DictValue<u128> {
     }
 }
 
-impl UpcastableInto<From, To, impl FromToUpcastable: Upcastable<From, To>> of Into<From, To> {
+impl UpcastableInto<From, To, +Upcastable<From, To>> of Into<From, To> {
     fn into(self: From) -> To {
         upcast(self)
     }
 }
 
-impl DowncastableTryInto<
-    From, To, impl FromToDowncastable: Downcastable<From, To>
+impl DowncastableIntTryInto<
+    From, To, +DowncastableInt<From>, +DowncastableInt<To>, -Into<From, To>
 > of TryInto<From, To> {
     fn try_into(self: From) -> Option<To> {
         downcast(self)
@@ -1778,109 +1856,24 @@ impl U256TryIntoU128 of TryInto<u256, u128> {
     }
 }
 
-// === Zeroable ===
-
-impl U8Zeroable of Zeroable<u8> {
-    fn zero() -> u8 {
-        0
-    }
-    #[inline(always)]
-    fn is_zero(self: u8) -> bool {
-        self == U8Zeroable::zero()
-    }
-    #[inline(always)]
-    fn is_non_zero(self: u8) -> bool {
-        self != U8Zeroable::zero()
-    }
-}
-
-impl U16Zeroable of Zeroable<u16> {
-    fn zero() -> u16 {
-        0
-    }
-    #[inline(always)]
-    fn is_zero(self: u16) -> bool {
-        self == U16Zeroable::zero()
-    }
-    #[inline(always)]
-    fn is_non_zero(self: u16) -> bool {
-        self != U16Zeroable::zero()
-    }
-}
-
-impl U32Zeroable of Zeroable<u32> {
-    fn zero() -> u32 {
-        0
-    }
-    #[inline(always)]
-    fn is_zero(self: u32) -> bool {
-        self == U32Zeroable::zero()
-    }
-    #[inline(always)]
-    fn is_non_zero(self: u32) -> bool {
-        self != U32Zeroable::zero()
-    }
-}
-
-impl U64Zeroable of Zeroable<u64> {
-    fn zero() -> u64 {
-        0
-    }
-    #[inline(always)]
-    fn is_zero(self: u64) -> bool {
-        self == U64Zeroable::zero()
-    }
-    #[inline(always)]
-    fn is_non_zero(self: u64) -> bool {
-        self != U64Zeroable::zero()
-    }
-}
-
-impl U128Zeroable of Zeroable<u128> {
-    fn zero() -> u128 {
-        0
-    }
-    #[inline(always)]
-    fn is_zero(self: u128) -> bool {
-        self == U128Zeroable::zero()
-    }
-    #[inline(always)]
-    fn is_non_zero(self: u128) -> bool {
-        self != U128Zeroable::zero()
-    }
-}
-
-impl U256Zeroable of Zeroable<u256> {
-    fn zero() -> u256 {
-        0
-    }
-    #[inline(always)]
-    fn is_zero(self: u256) -> bool {
-        self == U256Zeroable::zero()
-    }
-    #[inline(always)]
-    fn is_non_zero(self: u256) -> bool {
-        self != U256Zeroable::zero()
-    }
-}
-
 enum SignedIntegerResult<T> {
     InRange: T,
     Underflow: T,
     Overflow: T,
 }
-impl SignedIntegerResultDrop<T, impl TDrop: Drop<T>> of Drop<SignedIntegerResult<T>>;
+impl SignedIntegerResultDrop<T, +Drop<T>> of Drop<SignedIntegerResult<T>>;
 
 #[derive(Copy, Drop)]
-extern type i8;
+pub extern type i8;
 impl NumericLiterali8 of NumericLiteral<i8>;
-extern fn i8_const<value>() -> i8 nopanic;
 extern fn i8_try_from_felt252(a: felt252) -> Option<i8> implicits(RangeCheck) nopanic;
 extern fn i8_to_felt252(a: i8) -> felt252 nopanic;
 
 extern fn i8_is_zero(a: i8) -> IsZeroResult<i8> implicits() nopanic;
 extern fn i8_eq(lhs: i8, rhs: i8) -> bool implicits() nopanic;
 
+impl I8Serde = core::serde::into_felt252_based::SerdeImpl<i8>;
+
 impl I8PartialEq of PartialEq<i8> {
     #[inline(always)]
     fn eq(lhs: @i8, rhs: @i8) -> bool {
@@ -1902,8 +1895,8 @@ impl I8Add of Add<i8> {
     fn add(lhs: i8, rhs: i8) -> i8 {
         match i8_overflowing_add_impl(lhs, rhs) {
             SignedIntegerResult::InRange(result) => result,
-            SignedIntegerResult::Underflow(_) => panic_with_felt252('i8_add Underflow'),
-            SignedIntegerResult::Overflow(_) => panic_with_felt252('i8_add Overflow'),
+            SignedIntegerResult::Underflow(_) => core::panic_with_felt252('i8_add Underflow'),
+            SignedIntegerResult::Overflow(_) => core::panic_with_felt252('i8_add Overflow'),
         }
     }
 }
@@ -1917,8 +1910,8 @@ impl I8Sub of Sub<i8> {
     fn sub(lhs: i8, rhs: i8) -> i8 {
         match i8_overflowing_sub_impl(lhs, rhs) {
             SignedIntegerResult::InRange(result) => result,
-            SignedIntegerResult::Underflow(_) => panic_with_felt252('i8_sub Underflow'),
-            SignedIntegerResult::Overflow(_) => panic_with_felt252('i8_sub Overflow'),
+            SignedIntegerResult::Underflow(_) => core::panic_with_felt252('i8_sub Underflow'),
+            SignedIntegerResult::Overflow(_) => core::panic_with_felt252('i8_sub Overflow'),
         }
     }
 }
@@ -1936,10 +1929,10 @@ impl I8Neg of Neg<i8> {
     }
 }
 
-extern fn i8_wide_mul(lhs: i8, rhs: i8) -> i16 implicits() nopanic;
+pub extern fn i8_wide_mul(lhs: i8, rhs: i8) -> i16 implicits() nopanic;
 impl I8Mul of Mul<i8> {
     fn mul(lhs: i8, rhs: i8) -> i8 {
-        i8_try_from_felt252(i16_to_felt252(i8_wide_mul(lhs, rhs))).expect('i8_mul Overflow')
+        i8_wide_mul(lhs, rhs).try_into().expect('i8_mul Overflow')
     }
 }
 impl I8MulEq of MulEq<i8> {
@@ -1950,7 +1943,7 @@ impl I8MulEq of MulEq<i8> {
 }
 
 /// If `lhs` >= `rhs` returns `Ok(lhs - rhs)` else returns `Err(2**8 + lhs - rhs)`.
-extern fn i8_diff(lhs: i8, rhs: i8) -> Result<u8, u8> implicits(RangeCheck) nopanic;
+pub extern fn i8_diff(lhs: i8, rhs: i8) -> Result<u8, u8> implicits(RangeCheck) nopanic;
 impl I8PartialOrd of PartialOrd<i8> {
     #[inline(always)]
     fn le(lhs: i8, rhs: i8) -> bool {
@@ -1970,16 +1963,23 @@ impl I8PartialOrd of PartialOrd<i8> {
     }
 }
 
+impl I8BitSize of core::num::traits::BitSize<i8> {
+    fn bits() -> usize {
+        8
+    }
+}
+
 #[derive(Copy, Drop)]
-extern type i16;
+pub extern type i16;
 impl NumericLiterali16 of NumericLiteral<i16>;
-extern fn i16_const<value>() -> i16 nopanic;
 extern fn i16_try_from_felt252(a: felt252) -> Option<i16> implicits(RangeCheck) nopanic;
 extern fn i16_to_felt252(a: i16) -> felt252 nopanic;
 
 extern fn i16_is_zero(a: i16) -> IsZeroResult<i16> implicits() nopanic;
 extern fn i16_eq(lhs: i16, rhs: i16) -> bool implicits() nopanic;
 
+impl I16Serde = core::serde::into_felt252_based::SerdeImpl<i16>;
+
 impl I16PartialEq of PartialEq<i16> {
     #[inline(always)]
     fn eq(lhs: @i16, rhs: @i16) -> bool {
@@ -2001,8 +2001,8 @@ impl I16Add of Add<i16> {
     fn add(lhs: i16, rhs: i16) -> i16 {
         match i16_overflowing_add_impl(lhs, rhs) {
             SignedIntegerResult::InRange(result) => result,
-            SignedIntegerResult::Underflow(_) => panic_with_felt252('i16_add Underflow'),
-            SignedIntegerResult::Overflow(_) => panic_with_felt252('i16_add Overflow'),
+            SignedIntegerResult::Underflow(_) => core::panic_with_felt252('i16_add Underflow'),
+            SignedIntegerResult::Overflow(_) => core::panic_with_felt252('i16_add Overflow'),
         }
     }
 }
@@ -2016,8 +2016,8 @@ impl I16Sub of Sub<i16> {
     fn sub(lhs: i16, rhs: i16) -> i16 {
         match i16_overflowing_sub_impl(lhs, rhs) {
             SignedIntegerResult::InRange(result) => result,
-            SignedIntegerResult::Underflow(_) => panic_with_felt252('i16_sub Underflow'),
-            SignedIntegerResult::Overflow(_) => panic_with_felt252('i16_sub Overflow'),
+            SignedIntegerResult::Underflow(_) => core::panic_with_felt252('i16_sub Underflow'),
+            SignedIntegerResult::Overflow(_) => core::panic_with_felt252('i16_sub Overflow'),
         }
     }
 }
@@ -2035,10 +2035,10 @@ impl I16Neg of Neg<i16> {
     }
 }
 
-extern fn i16_wide_mul(lhs: i16, rhs: i16) -> i32 implicits() nopanic;
+pub extern fn i16_wide_mul(lhs: i16, rhs: i16) -> i32 implicits() nopanic;
 impl I16Mul of Mul<i16> {
     fn mul(lhs: i16, rhs: i16) -> i16 {
-        i16_try_from_felt252(i32_to_felt252(i16_wide_mul(lhs, rhs))).expect('i16_mul Overflow')
+        i16_wide_mul(lhs, rhs).try_into().expect('i16_mul Overflow')
     }
 }
 impl I16MulEq of MulEq<i16> {
@@ -2049,7 +2049,7 @@ impl I16MulEq of MulEq<i16> {
 }
 
 /// If `lhs` >= `rhs` returns `Ok(lhs - rhs)` else returns `Err(2**16 + lhs - rhs)`.
-extern fn i16_diff(lhs: i16, rhs: i16) -> Result<u16, u16> implicits(RangeCheck) nopanic;
+pub extern fn i16_diff(lhs: i16, rhs: i16) -> Result<u16, u16> implicits(RangeCheck) nopanic;
 impl I16PartialOrd of PartialOrd<i16> {
     #[inline(always)]
     fn le(lhs: i16, rhs: i16) -> bool {
@@ -2069,16 +2069,23 @@ impl I16PartialOrd of PartialOrd<i16> {
     }
 }
 
+impl I16BitSize of core::num::traits::BitSize<i16> {
+    fn bits() -> usize {
+        16
+    }
+}
+
 #[derive(Copy, Drop)]
-extern type i32;
+pub extern type i32;
 impl NumericLiterali32 of NumericLiteral<i32>;
-extern fn i32_const<value>() -> i32 nopanic;
 extern fn i32_try_from_felt252(a: felt252) -> Option<i32> implicits(RangeCheck) nopanic;
 extern fn i32_to_felt252(a: i32) -> felt252 nopanic;
 
 extern fn i32_is_zero(a: i32) -> IsZeroResult<i32> implicits() nopanic;
 extern fn i32_eq(lhs: i32, rhs: i32) -> bool implicits() nopanic;
 
+impl I32Serde = core::serde::into_felt252_based::SerdeImpl<i32>;
+
 impl I32PartialEq of PartialEq<i32> {
     #[inline(always)]
     fn eq(lhs: @i32, rhs: @i32) -> bool {
@@ -2100,8 +2107,8 @@ impl I32Add of Add<i32> {
     fn add(lhs: i32, rhs: i32) -> i32 {
         match i32_overflowing_add_impl(lhs, rhs) {
             SignedIntegerResult::InRange(result) => result,
-            SignedIntegerResult::Underflow(_) => panic_with_felt252('i32_add Underflow'),
-            SignedIntegerResult::Overflow(_) => panic_with_felt252('i32_add Overflow'),
+            SignedIntegerResult::Underflow(_) => core::panic_with_felt252('i32_add Underflow'),
+            SignedIntegerResult::Overflow(_) => core::panic_with_felt252('i32_add Overflow'),
         }
     }
 }
@@ -2115,8 +2122,8 @@ impl I32Sub of Sub<i32> {
     fn sub(lhs: i32, rhs: i32) -> i32 {
         match i32_overflowing_sub_impl(lhs, rhs) {
             SignedIntegerResult::InRange(result) => result,
-            SignedIntegerResult::Underflow(_) => panic_with_felt252('i32_sub Underflow'),
-            SignedIntegerResult::Overflow(_) => panic_with_felt252('i32_sub Overflow'),
+            SignedIntegerResult::Underflow(_) => core::panic_with_felt252('i32_sub Underflow'),
+            SignedIntegerResult::Overflow(_) => core::panic_with_felt252('i32_sub Overflow'),
         }
     }
 }
@@ -2134,10 +2141,10 @@ impl I32Neg of Neg<i32> {
     }
 }
 
-extern fn i32_wide_mul(lhs: i32, rhs: i32) -> i64 implicits() nopanic;
+pub extern fn i32_wide_mul(lhs: i32, rhs: i32) -> i64 implicits() nopanic;
 impl I32Mul of Mul<i32> {
     fn mul(lhs: i32, rhs: i32) -> i32 {
-        i32_try_from_felt252(i64_to_felt252(i32_wide_mul(lhs, rhs))).expect('i32_mul Overflow')
+        i32_wide_mul(lhs, rhs).try_into().expect('i32_mul Overflow')
     }
 }
 impl I32MulEq of MulEq<i32> {
@@ -2148,7 +2155,7 @@ impl I32MulEq of MulEq<i32> {
 }
 
 /// If `lhs` >= `rhs` returns `Ok(lhs - rhs)` else returns `Err(2**32 + lhs - rhs)`.
-extern fn i32_diff(lhs: i32, rhs: i32) -> Result<u32, u32> implicits(RangeCheck) nopanic;
+pub extern fn i32_diff(lhs: i32, rhs: i32) -> Result<u32, u32> implicits(RangeCheck) nopanic;
 impl I32PartialOrd of PartialOrd<i32> {
     #[inline(always)]
     fn le(lhs: i32, rhs: i32) -> bool {
@@ -2168,16 +2175,23 @@ impl I32PartialOrd of PartialOrd<i32> {
     }
 }
 
+impl I32BitSize of core::num::traits::BitSize<i32> {
+    fn bits() -> usize {
+        32
+    }
+}
+
 #[derive(Copy, Drop)]
-extern type i64;
+pub extern type i64;
 impl NumericLiterali64 of NumericLiteral<i64>;
-extern fn i64_const<value>() -> i64 nopanic;
 extern fn i64_try_from_felt252(a: felt252) -> Option<i64> implicits(RangeCheck) nopanic;
 extern fn i64_to_felt252(a: i64) -> felt252 nopanic;
 
 extern fn i64_is_zero(a: i64) -> IsZeroResult<i64> implicits() nopanic;
 extern fn i64_eq(lhs: i64, rhs: i64) -> bool implicits() nopanic;
 
+impl I64Serde = core::serde::into_felt252_based::SerdeImpl<i64>;
+
 impl I64PartialEq of PartialEq<i64> {
     #[inline(always)]
     fn eq(lhs: @i64, rhs: @i64) -> bool {
@@ -2199,8 +2213,8 @@ impl I64Add of Add<i64> {
     fn add(lhs: i64, rhs: i64) -> i64 {
         match i64_overflowing_add_impl(lhs, rhs) {
             SignedIntegerResult::InRange(result) => result,
-            SignedIntegerResult::Underflow(_) => panic_with_felt252('i64_add Underflow'),
-            SignedIntegerResult::Overflow(_) => panic_with_felt252('i64_add Overflow'),
+            SignedIntegerResult::Underflow(_) => core::panic_with_felt252('i64_add Underflow'),
+            SignedIntegerResult::Overflow(_) => core::panic_with_felt252('i64_add Overflow'),
         }
     }
 }
@@ -2214,8 +2228,8 @@ impl I64Sub of Sub<i64> {
     fn sub(lhs: i64, rhs: i64) -> i64 {
         match i64_overflowing_sub_impl(lhs, rhs) {
             SignedIntegerResult::InRange(result) => result,
-            SignedIntegerResult::Underflow(_) => panic_with_felt252('i64_sub Underflow'),
-            SignedIntegerResult::Overflow(_) => panic_with_felt252('i64_sub Overflow'),
+            SignedIntegerResult::Underflow(_) => core::panic_with_felt252('i64_sub Underflow'),
+            SignedIntegerResult::Overflow(_) => core::panic_with_felt252('i64_sub Overflow'),
         }
     }
 }
@@ -2233,10 +2247,10 @@ impl I64Neg of Neg<i64> {
     }
 }
 
-extern fn i64_wide_mul(lhs: i64, rhs: i64) -> i128 implicits() nopanic;
+pub extern fn i64_wide_mul(lhs: i64, rhs: i64) -> i128 implicits() nopanic;
 impl I64Mul of Mul<i64> {
     fn mul(lhs: i64, rhs: i64) -> i64 {
-        i64_try_from_felt252(i128_to_felt252(i64_wide_mul(lhs, rhs))).expect('i64_mul Overflow')
+        i64_wide_mul(lhs, rhs).try_into().expect('i64_mul Overflow')
     }
 }
 impl I64MulEq of MulEq<i64> {
@@ -2247,7 +2261,7 @@ impl I64MulEq of MulEq<i64> {
 }
 
 /// If `lhs` >= `rhs` returns `Ok(lhs - rhs)` else returns `Err(2**64 + lhs - rhs)`.
-extern fn i64_diff(lhs: i64, rhs: i64) -> Result<u64, u64> implicits(RangeCheck) nopanic;
+pub extern fn i64_diff(lhs: i64, rhs: i64) -> Result<u64, u64> implicits(RangeCheck) nopanic;
 impl I64PartialOrd of PartialOrd<i64> {
     #[inline(always)]
     fn le(lhs: i64, rhs: i64) -> bool {
@@ -2267,16 +2281,23 @@ impl I64PartialOrd of PartialOrd<i64> {
     }
 }
 
+impl I64BitSize of core::num::traits::BitSize<i64> {
+    fn bits() -> usize {
+        64
+    }
+}
+
 #[derive(Copy, Drop)]
-extern type i128;
+pub extern type i128;
 impl NumericLiterali128 of NumericLiteral<i128>;
-extern fn i128_const<value>() -> i128 nopanic;
 extern fn i128_try_from_felt252(a: felt252) -> Option<i128> implicits(RangeCheck) nopanic;
 extern fn i128_to_felt252(a: i128) -> felt252 nopanic;
 
 extern fn i128_is_zero(a: i128) -> IsZeroResult<i128> implicits() nopanic;
 extern fn i128_eq(lhs: i128, rhs: i128) -> bool implicits() nopanic;
 
+impl I128Serde = core::serde::into_felt252_based::SerdeImpl<i128>;
+
 impl I128PartialEq of PartialEq<i128> {
     #[inline(always)]
     fn eq(lhs: @i128, rhs: @i128) -> bool {
@@ -2298,8 +2319,8 @@ impl I128Add of Add<i128> {
     fn add(lhs: i128, rhs: i128) -> i128 {
         match i128_overflowing_add_impl(lhs, rhs) {
             SignedIntegerResult::InRange(result) => result,
-            SignedIntegerResult::Underflow(_) => panic_with_felt252('i128_add Underflow'),
-            SignedIntegerResult::Overflow(_) => panic_with_felt252('i128_add Overflow'),
+            SignedIntegerResult::Underflow(_) => core::panic_with_felt252('i128_add Underflow'),
+            SignedIntegerResult::Overflow(_) => core::panic_with_felt252('i128_add Overflow'),
         }
     }
 }
@@ -2313,8 +2334,8 @@ impl I128Sub of Sub<i128> {
     fn sub(lhs: i128, rhs: i128) -> i128 {
         match i128_overflowing_sub_impl(lhs, rhs) {
             SignedIntegerResult::InRange(result) => result,
-            SignedIntegerResult::Underflow(_) => panic_with_felt252('i128_sub Underflow'),
-            SignedIntegerResult::Overflow(_) => panic_with_felt252('i128_sub Overflow'),
+            SignedIntegerResult::Underflow(_) => core::panic_with_felt252('i128_sub Underflow'),
+            SignedIntegerResult::Overflow(_) => core::panic_with_felt252('i128_sub Overflow'),
         }
     }
 }
@@ -2332,8 +2353,34 @@ impl I128Neg of Neg<i128> {
     }
 }
 
+impl I128Mul of Mul<i128> {
+    fn mul(lhs: i128, rhs: i128) -> i128 {
+        let (lhs_u127, lhs_neg) = match i128_diff(lhs, 0) {
+            Result::Ok(v) => (v, false),
+            Result::Err(v) => (~v + 1, true),
+        };
+        let (rhs_u127, res_neg) = match i128_diff(rhs, 0) {
+            Result::Ok(v) => (v, lhs_neg),
+            Result::Err(v) => (~v + 1, !lhs_neg),
+        };
+        let res_as_u128 = lhs_u127 * rhs_u127;
+        let res_as_felt252: felt252 = if res_neg {
+            -res_as_u128.into()
+        } else {
+            res_as_u128.into()
+        };
+        res_as_felt252.try_into().expect('i128_mul Overflow')
+    }
+}
+impl I128MulEq of MulEq<i128> {
+    #[inline(always)]
+    fn mul_eq(ref self: i128, other: i128) {
+        self = Mul::mul(self, other);
+    }
+}
+
 /// If `lhs` >= `rhs` returns `Ok(lhs - rhs)` else returns `Err(2**128 + lhs - rhs)`.
-extern fn i128_diff(lhs: i128, rhs: i128) -> Result<u128, u128> implicits(RangeCheck) nopanic;
+pub extern fn i128_diff(lhs: i128, rhs: i128) -> Result<u128, u128> implicits(RangeCheck) nopanic;
 impl I128PartialOrd of PartialOrd<i128> {
     #[inline(always)]
     fn le(lhs: i128, rhs: i128) -> bool {
@@ -2352,3 +2399,338 @@ impl I128PartialOrd of PartialOrd<i128> {
         i128_diff(rhs, lhs).into_is_err()
     }
 }
+
+// Zeroable impls
+pub(crate) impl U8Zeroable = core::zeroable::zero_based::ZeroableImpl<u8, U8Zero>;
+pub(crate) impl U16Zeroable = core::zeroable::zero_based::ZeroableImpl<u16, U16Zero>;
+pub(crate) impl U32Zeroable = core::zeroable::zero_based::ZeroableImpl<u32, U32Zero>;
+pub(crate) impl U64Zeroable = core::zeroable::zero_based::ZeroableImpl<u64, U64Zero>;
+pub(crate) impl U128Zeroable = core::zeroable::zero_based::ZeroableImpl<u128, U128Zero>;
+pub(crate) impl U256Zeroable = core::zeroable::zero_based::ZeroableImpl<u256, U256Zero>;
+
+impl I128BitSize of core::num::traits::BitSize<i128> {
+    fn bits() -> usize {
+        128
+    }
+}
+
+// Zero trait implementations
+impl U8Zero of core::num::traits::Zero<u8> {
+    fn zero() -> u8 {
+        0
+    }
+    #[inline(always)]
+    fn is_zero(self: @u8) -> bool {
+        *self == U8Zero::zero()
+    }
+    #[inline(always)]
+    fn is_non_zero(self: @u8) -> bool {
+        !self.is_zero()
+    }
+}
+
+impl U16Zero of core::num::traits::Zero<u16> {
+    fn zero() -> u16 {
+        0
+    }
+    #[inline(always)]
+    fn is_zero(self: @u16) -> bool {
+        *self == U16Zero::zero()
+    }
+    #[inline(always)]
+    fn is_non_zero(self: @u16) -> bool {
+        !self.is_zero()
+    }
+}
+
+impl U32Zero of core::num::traits::Zero<u32> {
+    fn zero() -> u32 {
+        0
+    }
+    #[inline(always)]
+    fn is_zero(self: @u32) -> bool {
+        *self == U32Zero::zero()
+    }
+    #[inline(always)]
+    fn is_non_zero(self: @u32) -> bool {
+        !self.is_zero()
+    }
+}
+
+impl U64Zero of core::num::traits::Zero<u64> {
+    fn zero() -> u64 {
+        0
+    }
+    #[inline(always)]
+    fn is_zero(self: @u64) -> bool {
+        *self == U64Zero::zero()
+    }
+    #[inline(always)]
+    fn is_non_zero(self: @u64) -> bool {
+        !self.is_zero()
+    }
+}
+
+impl U128Zero of core::num::traits::Zero<u128> {
+    fn zero() -> u128 {
+        0
+    }
+    #[inline(always)]
+    fn is_zero(self: @u128) -> bool {
+        *self == U128Zero::zero()
+    }
+    #[inline(always)]
+    fn is_non_zero(self: @u128) -> bool {
+        !self.is_zero()
+    }
+}
+
+impl U256Zero of core::num::traits::Zero<u256> {
+    fn zero() -> u256 {
+        0
+    }
+    #[inline(always)]
+    fn is_zero(self: @u256) -> bool {
+        *self == U256Zero::zero()
+    }
+    #[inline(always)]
+    fn is_non_zero(self: @u256) -> bool {
+        !self.is_zero()
+    }
+}
+
+impl I8Zero of core::num::traits::Zero<i8> {
+    fn zero() -> i8 {
+        0
+    }
+    #[inline(always)]
+    fn is_zero(self: @i8) -> bool {
+        *self == I8Zero::zero()
+    }
+    #[inline(always)]
+    fn is_non_zero(self: @i8) -> bool {
+        !self.is_zero()
+    }
+}
+
+impl I16Zero of core::num::traits::Zero<i16> {
+    fn zero() -> i16 {
+        0
+    }
+    #[inline(always)]
+    fn is_zero(self: @i16) -> bool {
+        *self == I16Zero::zero()
+    }
+    #[inline(always)]
+    fn is_non_zero(self: @i16) -> bool {
+        !self.is_zero()
+    }
+}
+
+impl I32Zero of core::num::traits::Zero<i32> {
+    fn zero() -> i32 {
+        0
+    }
+    #[inline(always)]
+    fn is_zero(self: @i32) -> bool {
+        *self == I32Zero::zero()
+    }
+    #[inline(always)]
+    fn is_non_zero(self: @i32) -> bool {
+        !self.is_zero()
+    }
+}
+
+impl I64Zero of core::num::traits::Zero<i64> {
+    fn zero() -> i64 {
+        0
+    }
+    #[inline(always)]
+    fn is_zero(self: @i64) -> bool {
+        *self == I64Zero::zero()
+    }
+    #[inline(always)]
+    fn is_non_zero(self: @i64) -> bool {
+        !self.is_zero()
+    }
+}
+
+impl I128Zero of core::num::traits::Zero<i128> {
+    fn zero() -> i128 {
+        0
+    }
+    #[inline(always)]
+    fn is_zero(self: @i128) -> bool {
+        *self == I128Zero::zero()
+    }
+    #[inline(always)]
+    fn is_non_zero(self: @i128) -> bool {
+        !self.is_zero()
+    }
+}
+
+
+// One trait implementations
+impl U8One of core::num::traits::One<u8> {
+    fn one() -> u8 {
+        1
+    }
+    #[inline(always)]
+    fn is_one(self: @u8) -> bool {
+        *self == U8One::one()
+    }
+    #[inline(always)]
+    fn is_non_one(self: @u8) -> bool {
+        !self.is_one()
+    }
+}
+
+impl U16One of core::num::traits::One<u16> {
+    fn one() -> u16 {
+        1
+    }
+    #[inline(always)]
+    fn is_one(self: @u16) -> bool {
+        *self == U16One::one()
+    }
+    #[inline(always)]
+    fn is_non_one(self: @u16) -> bool {
+        !self.is_one()
+    }
+}
+
+impl U32One of core::num::traits::One<u32> {
+    fn one() -> u32 {
+        1
+    }
+    #[inline(always)]
+    fn is_one(self: @u32) -> bool {
+        *self == U32One::one()
+    }
+    #[inline(always)]
+    fn is_non_one(self: @u32) -> bool {
+        !self.is_one()
+    }
+}
+
+impl U64One of core::num::traits::One<u64> {
+    fn one() -> u64 {
+        1
+    }
+    #[inline(always)]
+    fn is_one(self: @u64) -> bool {
+        *self == U64One::one()
+    }
+    #[inline(always)]
+    fn is_non_one(self: @u64) -> bool {
+        !self.is_one()
+    }
+}
+
+impl U128One of core::num::traits::One<u128> {
+    fn one() -> u128 {
+        1
+    }
+    #[inline(always)]
+    fn is_one(self: @u128) -> bool {
+        *self == U128One::one()
+    }
+    #[inline(always)]
+    fn is_non_one(self: @u128) -> bool {
+        !self.is_one()
+    }
+}
+
+impl U256One of core::num::traits::One<u256> {
+    fn one() -> u256 {
+        1
+    }
+    #[inline(always)]
+    fn is_one(self: @u256) -> bool {
+        *self == U256One::one()
+    }
+    #[inline(always)]
+    fn is_non_one(self: @u256) -> bool {
+        !self.is_one()
+    }
+}
+
+impl I8One of core::num::traits::One<i8> {
+    fn one() -> i8 {
+        1
+    }
+
+    #[inline(always)]
+    fn is_one(self: @i8) -> bool {
+        *self == I8One::one()
+    }
+
+    #[inline(always)]
+    fn is_non_one(self: @i8) -> bool {
+        !self.is_one()
+    }
+}
+
+impl I16One of core::num::traits::One<i16> {
+    fn one() -> i16 {
+        1
+    }
+
+    #[inline(always)]
+    fn is_one(self: @i16) -> bool {
+        *self == I16One::one()
+    }
+
+    #[inline(always)]
+    fn is_non_one(self: @i16) -> bool {
+        !self.is_one()
+    }
+}
+
+impl I32One of core::num::traits::One<i32> {
+    fn one() -> i32 {
+        1
+    }
+
+    #[inline(always)]
+    fn is_one(self: @i32) -> bool {
+        *self == I32One::one()
+    }
+
+    #[inline(always)]
+    fn is_non_one(self: @i32) -> bool {
+        !self.is_one()
+    }
+}
+
+impl I64One of core::num::traits::One<i64> {
+    fn one() -> i64 {
+        1
+    }
+
+    #[inline(always)]
+    fn is_one(self: @i64) -> bool {
+        *self == I64One::one()
+    }
+
+    #[inline(always)]
+    fn is_non_one(self: @i64) -> bool {
+        !self.is_one()
+    }
+}
+
+impl I128One of core::num::traits::One<i128> {
+    fn one() -> i128 {
+        1
+    }
+
+    #[inline(always)]
+    fn is_one(self: @i128) -> bool {
+        *self == I128One::one()
+    }
+
+    #[inline(always)]
+    fn is_non_one(self: @i128) -> bool {
+        !self.is_one()
+    }
+}
diff --git a/corelib/src/internal.cairo b/corelib/src/internal.cairo
index 49a4ee6..5e2a736 100644
--- a/corelib/src/internal.cairo
+++ b/corelib/src/internal.cairo
@@ -1,6 +1,12 @@
-extern fn revoke_ap_tracking() implicits() nopanic;
+pub extern fn revoke_ap_tracking() implicits() nopanic;
 
 /// Function to enforce that `Implicit` is used by a function calling it.
 /// Note: This extern function is not mapped to a Sierra function, and all usages of it are removed
 /// during compilation.
-extern fn require_implicit<Implicit>() implicits(Implicit) nopanic;
+pub extern fn require_implicit<Implicit>() implicits(Implicit) nopanic;
+
+extern type index_enum_type<const NUM_VARIANTS: felt252>;
+
+extern type BoundedInt<const MIN: felt252, const MAX: felt252>;
+
+extern fn constrain_range<T, S>(value: T) -> Option<S> implicits(RangeCheck) nopanic;
diff --git a/corelib/src/keccak.cairo b/corelib/src/keccak.cairo
index 080fffc..3bad213 100644
--- a/corelib/src/keccak.cairo
+++ b/corelib/src/keccak.cairo
@@ -1,7 +1,7 @@
-use array::{Span, ArrayTrait, SpanTrait};
-use integer::TryInto;
-use option::OptionTrait;
-use starknet::SyscallResultTrait;
+use core::array::{Span, ArrayTrait, SpanTrait};
+use core::traits::TryInto;
+use core::option::OptionTrait;
+use core::starknet::SyscallResultTrait;
 
 const KECCAK_FULL_RATE_IN_BYTES: usize = 136;
 const KECCAK_FULL_RATE_IN_U64S: usize = 17;
@@ -13,7 +13,7 @@ fn u128_to_u64(input: u128) -> u64 {
 }
 
 fn u128_split(input: u128) -> (u64, u64) {
-    let (high, low) = integer::u128_safe_divmod(
+    let (high, low) = core::integer::u128_safe_divmod(
         input, 0x10000000000000000_u128.try_into().unwrap()
     );
 
@@ -33,17 +33,13 @@ fn keccak_add_u256_le(ref keccak_input: Array::<u64>, v: u256) {
 // Computes the keccak256 of multiple u256 values.
 // The input values are interpreted as little-endian.
 // The 32-byte result is represented as a little-endian u256.
-fn keccak_u256s_le_inputs(mut input: Span<u256>) -> u256 {
+pub fn keccak_u256s_le_inputs(mut input: Span<u256>) -> u256 {
     let mut keccak_input: Array::<u64> = Default::default();
 
     loop {
         match input.pop_front() {
-            Option::Some(v) => {
-                keccak_add_u256_le(ref keccak_input, *v);
-            },
-            Option::None => {
-                break ();
-            },
+            Option::Some(v) => { keccak_add_u256_le(ref keccak_input, *v); },
+            Option::None => { break (); },
         };
     };
 
@@ -52,10 +48,10 @@ fn keccak_u256s_le_inputs(mut input: Span<u256>) -> u256 {
 }
 
 fn keccak_add_u256_be(ref keccak_input: Array::<u64>, v: u256) {
-    let (high, low) = u128_split(integer::u128_byte_reverse(v.high));
+    let (high, low) = u128_split(core::integer::u128_byte_reverse(v.high));
     keccak_input.append(low);
     keccak_input.append(high);
-    let (high, low) = u128_split(integer::u128_byte_reverse(v.low));
+    let (high, low) = u128_split(core::integer::u128_byte_reverse(v.low));
     keccak_input.append(low);
     keccak_input.append(high);
 }
@@ -63,17 +59,13 @@ fn keccak_add_u256_be(ref keccak_input: Array::<u64>, v: u256) {
 // Computes the keccak256 of multiple u256 values.
 // The input values are interpreted as big-endian.
 // The 32-byte result is represented as a little-endian u256.
-fn keccak_u256s_be_inputs(mut input: Span<u256>) -> u256 {
+pub fn keccak_u256s_be_inputs(mut input: Span<u256>) -> u256 {
     let mut keccak_input: Array::<u64> = Default::default();
 
     loop {
         match input.pop_front() {
-            Option::Some(v) => {
-                keccak_add_u256_be(ref keccak_input, *v);
-            },
-            Option::None => {
-                break ();
-            },
+            Option::Some(v) => { keccak_add_u256_be(ref keccak_input, *v); },
+            Option::None => { break (); },
         };
     };
 
@@ -90,7 +82,9 @@ fn keccak_u256s_be_inputs(mut input: Span<u256>) -> u256 {
 //   560229490 == int.from_bytes(b'rld!', 'little')
 //
 // Returns the hash as a little endian u256.
-fn cairo_keccak(ref input: Array<u64>, last_input_word: u64, last_input_num_bytes: usize) -> u256 {
+pub fn cairo_keccak(
+    ref input: Array<u64>, last_input_word: u64, last_input_num_bytes: usize
+) -> u256 {
     add_padding(ref input, last_input_word, last_input_num_bytes);
     starknet::syscalls::keccak_syscall(input.span()).unwrap_syscall()
 }
@@ -100,9 +94,7 @@ fn cairo_keccak(ref input: Array<u64>, last_input_word: u64, last_input_num_byte
 fn add_padding(ref input: Array<u64>, last_input_word: u64, last_input_num_bytes: usize) {
     let words_divisor = KECCAK_FULL_RATE_IN_U64S.try_into().unwrap();
     // `last_block_num_full_words` is in range [0, KECCAK_FULL_RATE_IN_U64S - 1]
-    let (_, last_block_num_full_words) = integer::u32_safe_divmod(input.len(), words_divisor);
-    // `last_block_num_bytes` is in range [0, KECCAK_FULL_RATE_IN_BYTES - 1]
-    let last_block_num_bytes = last_block_num_full_words * BYTES_IN_U64_WORD + last_input_num_bytes;
+    let (_, last_block_num_full_words) = core::integer::u32_safe_divmod(input.len(), words_divisor);
 
     // The first word to append would be of the form
     //     0x1<`last_input_num_bytes` LSB bytes of `last_input_word`>.
@@ -127,9 +119,9 @@ fn add_padding(ref input: Array<u64>, last_input_word: u64, last_input_num_bytes
         } else if last_input_num_bytes == 7 {
             0x100000000000000
         } else {
-            panic_with_felt252('Keccak last input word >7b')
+            core::panic_with_felt252('Keccak last input word >7b')
         };
-        let (_, r) = integer::u64_safe_divmod(
+        let (_, r) = core::integer::u64_safe_divmod(
             last_input_word, first_padding_byte_part.try_into().unwrap()
         );
         first_padding_byte_part + r
diff --git a/corelib/src/lib.cairo b/corelib/src/lib.cairo
index e41b936..677f931 100644
--- a/corelib/src/lib.cairo
+++ b/corelib/src/lib.cairo
@@ -1,4 +1,4 @@
-mod traits;
+pub mod traits;
 use traits::{
     Add, AddEq, BitAnd, BitNot, BitOr, BitXor, Copy, Div, DivEq, DivRem, Drop, Mul, MulEq,
     PartialEq, PartialOrd, Rem, RemEq, Sub, SubEq, TupleSize0Copy, TupleSize0Drop, Not, Neg, Into,
@@ -6,10 +6,10 @@ use traits::{
 };
 use serde::Serde;
 
-type usize = u32;
+pub type usize = u32;
 
 #[derive(Copy, Drop, Default)]
-enum bool {
+pub enum bool {
     #[default]
     False,
     True,
@@ -18,9 +18,9 @@ enum bool {
 impl BoolSerde of Serde<bool> {
     fn serialize(self: @bool, ref output: Array<felt252>) {
         if *self {
-            1
+            1_felt252
         } else {
-            0
+            0_felt252
         }.serialize(ref output);
     }
     fn deserialize(ref serialized: Span<felt252>) -> Option<bool> {
@@ -69,15 +69,15 @@ impl BoolPartialEq of PartialEq<bool> {
     #[inline(always)]
     fn eq(lhs: @bool, rhs: @bool) -> bool {
         match lhs {
-            bool::False => !*rhs,
-            bool::True => *rhs,
+            false => !*rhs,
+            true => *rhs,
         }
     }
     #[inline(always)]
     fn ne(lhs: @bool, rhs: @bool) -> bool {
         match lhs {
-            bool::False => *rhs,
-            bool::True => !*rhs,
+            false => *rhs,
+            true => !*rhs,
         }
     }
 }
@@ -97,14 +97,18 @@ impl BoolIntoFelt252 of Into<bool, felt252> {
         bool_to_felt252(self)
     }
 }
+pub mod boolean;
 
 // General purpose implicits.
-extern type RangeCheck;
-extern type SegmentArena;
+pub extern type RangeCheck;
+pub extern type SegmentArena;
 
 // felt252.
+mod felt_252;
+use felt_252::{Felt252One, Felt252Zero};
+
 #[derive(Copy, Drop)]
-extern type felt252;
+pub extern type felt252;
 extern fn felt252_const<const value: felt252>() -> felt252 nopanic;
 
 impl Felt252Serde of Serde<felt252> {
@@ -166,14 +170,14 @@ impl Felt252Neg of Neg<felt252> {
     }
 }
 
-extern fn felt252_div(lhs: felt252, rhs: NonZero<felt252>) -> felt252 nopanic;
+pub extern fn felt252_div(lhs: felt252, rhs: NonZero<felt252>) -> felt252 nopanic;
 
 impl Felt252PartialEq of PartialEq<felt252> {
     #[inline(always)]
     fn eq(lhs: @felt252, rhs: @felt252) -> bool {
         match *lhs - *rhs {
-            0 => bool::True(()),
-            _ => bool::False(()),
+            0 => true,
+            _ => false,
         }
     }
     #[inline(always)]
@@ -212,127 +216,144 @@ extern fn dup<T>(obj: T) -> (T, T) nopanic;
 extern fn drop<T>(obj: T) nopanic;
 
 // Boxes.
-mod box;
+pub mod box;
 use box::{Box, BoxTrait};
 
 // Nullable
-mod nullable;
+pub mod nullable;
 use nullable::{Nullable, NullableTrait, match_nullable, null, nullable_from_box};
 
 // Array.
-mod array;
+pub mod array;
 use array::{Array, ArrayTrait};
 
 // Span.
 use array::{Span, SpanTrait};
 
 // Dictionary.
-mod dict;
+pub mod dict;
 use dict::{
     Felt252Dict, SquashedFelt252Dict, felt252_dict_new, felt252_dict_squash, Felt252DictTrait
 };
 
 // Result.
-mod result;
+pub mod result;
 use result::{Result, ResultTrait};
 
 // Option.
-mod option;
+pub mod option;
 use option::{Option, OptionTrait};
 
 // Clone.
-mod clone;
+pub mod clone;
 use clone::Clone;
 
 // EC.
-mod ec;
+pub mod ec;
 use ec::{EcOp, EcPoint, EcState};
 
-mod ecdsa;
+pub mod ecdsa;
 
 // Integer.
-mod integer;
+pub mod integer;
 use integer::{
-    i8, i8_const, I8IntoFelt252, i16, i16_const, I16IntoFelt252, i32, i32_const, I32IntoFelt252,
-    i64, i64_const, I64IntoFelt252, i128, i128_const, I128IntoFelt252, NumericLiteral, u128,
-    u128_const, u128_sqrt, u128_is_zero, u8, u8_const, u16, u16_const, u32, u32_const, u64,
-    u64_const, u256, u256_sqrt, Felt252TryIntoU8, U8IntoFelt252, Felt252TryIntoU16, U16IntoFelt252,
+    i8, I8IntoFelt252, i16, I16IntoFelt252, i32, I32IntoFelt252, i64, I64IntoFelt252, i128,
+    I128IntoFelt252, NumericLiteral, u128, u128_sqrt, u128_is_zero, u8, u16, u32, u64, u256,
+    u256_sqrt, Felt252TryIntoU8, U8IntoFelt252, Felt252TryIntoU16, U16IntoFelt252,
     Felt252TryIntoU32, U32IntoFelt252, Felt252TryIntoU64, U64IntoFelt252, Felt252TryIntoU128,
     U128IntoFelt252, Felt252IntoU256, Bitwise
 };
 
 // Math.
-mod math;
+pub mod math;
+
+// Num.
+pub mod num;
 
 // Cmp.
-mod cmp;
+pub mod cmp;
 
 // Gas.
-mod gas;
+pub mod gas;
 use gas::{BuiltinCosts, GasBuiltin, get_builtin_costs};
 
 
 // Panics.
-mod panics;
+pub mod panics;
 use panics::{panic, Panic, PanicResult};
 
-enum never {}
+pub enum never {}
 
 #[inline(always)]
-fn panic_with_felt252(err_code: felt252) -> never {
+pub fn panic_with_felt252(err_code: felt252) -> never {
     panic(array![err_code])
 }
 
 #[inline(always)]
-fn assert(cond: bool, err_code: felt252) {
+pub fn assert(cond: bool, err_code: felt252) {
     if !cond {
         panic_with_felt252(err_code)
     }
 }
 
 // Serialization and Deserialization.
-mod serde;
+pub mod serde;
 
 // Hash functions.
-mod hash;
+pub mod hash;
 
-mod keccak;
+pub mod keccak;
 
 // Pedersen
-mod pedersen;
+pub mod pedersen;
 use pedersen::Pedersen;
 
 // Poseidon
-mod poseidon;
+pub mod poseidon;
 use poseidon::Poseidon;
 
 // Debug.
-mod debug;
+pub mod debug;
+
+pub mod fmt;
 
 // Starknet
-mod starknet;
+pub mod starknet;
 use starknet::System;
 
 // Internals.
-mod internal;
+pub mod internal;
 
 // Zeroable.
-mod zeroable;
+pub mod zeroable;
 use zeroable::{Zeroable, NonZero};
 
 // bytes31.
-mod bytes_31;
+pub mod bytes_31;
 use bytes_31::{
     bytes31, bytes31_const, Bytes31IndexView, Bytes31IntoFelt252, Bytes31Trait,
     Felt252TryIntoBytes31
 };
 
 // BytesArray.
-mod byte_array;
-use byte_array::{ByteArray, ByteArrayIndexView, ByteArrayTrait};
+pub mod byte_array;
+use byte_array::{ByteArray, ByteArrayIndexView, ByteArrayStringLiteral, ByteArrayTrait};
+
+// String.
+pub mod string;
+use string::StringLiteral;
+
+// to_byte_array.
+pub mod to_byte_array;
 
 #[cfg(test)]
 mod test;
 
 // Module for testing only.
-mod testing;
+pub mod testing;
+
+// Metaprogramming.
+pub mod metaprogramming;
+
+// Preludes.
+mod prelude;
diff --git a/corelib/src/math.cairo b/corelib/src/math.cairo
index 708222e..e1ea082 100644
--- a/corelib/src/math.cairo
+++ b/corelib/src/math.cairo
@@ -1,7 +1,7 @@
-use zeroable::{IsZeroResult, NonZeroIntoImpl, Zeroable};
-use traits::{Into, TryInto};
-use option::OptionTrait;
-use integer::{u256_wide_mul, u512_safe_div_rem_by_u256};
+use core::zeroable::{IsZeroResult, NonZeroIntoImpl, Zeroable};
+use core::traits::{Into, TryInto};
+use core::option::OptionTrait;
+use core::integer::{u256_wide_mul, u512_safe_div_rem_by_u256, U128MulGuarantee};
 
 // TODO(yuval): use signed integers once supported.
 // TODO(yuval): use a single impl of a trait with associated impls, once associated impls are
@@ -12,23 +12,23 @@ use integer::{u256_wide_mul, u512_safe_div_rem_by_u256};
 /// `(s, -t)` or `(-s, t)` are the Bezout coefficients (according to `sub_direction`).
 ///
 /// Uses the Extended Euclidean algorithm.
-fn egcd<
+pub fn egcd<
     T,
-    impl TCopyImpl: Copy<T>,
-    impl TDropImpl: Drop<T>,
-    impl TAddImpl: Add<T>,
-    impl TMulImpl: Mul<T>,
-    impl TDivRemImpl: DivRem<T>,
-    impl TZeroableImpl: Zeroable<T>,
-    impl TOneableImpl: Oneable<T>,
-    impl TTryIntoNonZeroImpl: TryInto<T, NonZero<T>>,
+    +Copy<T>,
+    +Drop<T>,
+    +Add<T>,
+    +Mul<T>,
+    +DivRem<T>,
+    +Zeroable<T>,
+    +Oneable<T>,
+    +TryInto<T, NonZero<T>>,
 >(
     a: NonZero<T>, b: NonZero<T>
 ) -> (T, T, T, bool) {
-    let (q, r) = TDivRemImpl::div_rem(a.into(), b);
+    let (q, r) = DivRem::<T>::div_rem(a.into(), b);
 
     if r.is_zero() {
-        return (b.into(), TZeroableImpl::zero(), TOneableImpl::one(), false);
+        return (b.into(), Zeroable::zero(), Oneable::one(), false);
     }
 
     // `sign` (1 for true, -1 for false) is the sign of `g` in the current iteration.
@@ -42,22 +42,22 @@ fn egcd<
 
 // TODO(yuval): use signed integers once supported.
 /// Returns the inverse of `a` modulo `n`, or None if `gcd(a, n) > 1`.
-fn inv_mod<
+pub fn inv_mod<
     T,
-    impl TCopyImpl: Copy<T>,
-    impl TDropImpl: Drop<T>,
-    impl TAddImpl: Add<T>,
-    impl TSubImpl: Sub<T>,
-    impl TMulImpl: Mul<T>,
-    impl TDivRemImpl: DivRem<T>,
-    impl TZeroableImpl: Zeroable<T>,
-    impl TOneableImpl: Oneable<T>,
-    impl TTryIntoNonZeroImpl: TryInto<T, NonZero<T>>,
+    +Copy<T>,
+    +Drop<T>,
+    +Add<T>,
+    +Sub<T>,
+    +Mul<T>,
+    +DivRem<T>,
+    +Zeroable<T>,
+    +Oneable<T>,
+    +TryInto<T, NonZero<T>>,
 >(
     a: NonZero<T>, n: NonZero<T>
 ) -> Option<T> {
-    if TOneableImpl::is_one(n.into()) {
-        return Option::Some(TZeroableImpl::zero());
+    if Oneable::<T>::is_one(n.into()) {
+        return Option::Some(Zeroable::zero());
     }
     let (g, s, _, sub_direction) = egcd(a, n);
     if g.is_one() {
@@ -77,13 +77,44 @@ fn inv_mod<
     }
 }
 
+/// Returns `1 / b (mod n)`, or None if `b` is not invertible modulo `n`.
+/// All `b`s will be considered not invertible for `n == 1`.
+/// Additionally returns several `U128MulGuarantee`s that are required for validating the
+/// calculation.
+extern fn u256_guarantee_inv_mod_n(
+    b: u256, n: NonZero<u256>
+) -> Result<
+    (
+        NonZero<u256>,
+        U128MulGuarantee,
+        U128MulGuarantee,
+        U128MulGuarantee,
+        U128MulGuarantee,
+        U128MulGuarantee,
+        U128MulGuarantee,
+        U128MulGuarantee,
+        U128MulGuarantee
+    ),
+    (U128MulGuarantee, U128MulGuarantee)
+> implicits(RangeCheck) nopanic;
+
+/// Returns the inverse of `a` modulo `n`, or None if `a` is not invertible modulo `n`.
+/// All `b`s will be considered not invertible for `n == 1`.
+#[inline(always)]
+pub fn u256_inv_mod(a: u256, n: NonZero<u256>) -> Option<NonZero<u256>> {
+    match u256_guarantee_inv_mod_n(a, n) {
+        Result::Ok((inv_a, _, _, _, _, _, _, _, _)) => Option::Some(inv_a),
+        Result::Err(_) => Option::None(())
+    }
+}
+
 /// Returns `a / b (mod n)`, or None if `b` is not invertible modulo `n`.
-fn u256_div_mod_n(a: u256, b: NonZero<u256>, n: NonZero<u256>) -> Option<u256> {
-    Option::Some(u256_mul_mod_n(a, inv_mod(b, n)?, n))
+pub fn u256_div_mod_n(a: u256, b: u256, n: NonZero<u256>) -> Option<u256> {
+    Option::Some(u256_mul_mod_n(a, u256_inv_mod(b, n)?.into(), n))
 }
 
 /// Returns `a * b (mod n)`.
-fn u256_mul_mod_n(a: u256, b: u256, n: NonZero<u256>) -> u256 {
+pub fn u256_mul_mod_n(a: u256, b: u256, n: NonZero<u256>) -> u256 {
     let (_, r) = u512_safe_div_rem_by_u256(u256_wide_mul(a, b), n);
     r
 }
@@ -92,93 +123,38 @@ fn u256_mul_mod_n(a: u256, b: u256, n: NonZero<u256>) -> u256 {
 
 trait Oneable<T> {
     /// Returns the multiplicative identity element of Self, 1.
+    #[must_use]
     fn one() -> T;
     /// Returns whether self is equal to 1, the multiplicative identity element.
+    #[must_use]
     fn is_one(self: T) -> bool;
     /// Returns whether self is not equal to 1, the multiplicative identity element.
+    #[must_use]
     fn is_non_one(self: T) -> bool;
 }
 
-impl U8Oneable of Oneable<u8> {
-    fn one() -> u8 {
-        1
-    }
-    #[inline(always)]
-    fn is_one(self: u8) -> bool {
-        self == U8Oneable::one()
-    }
-    #[inline(always)]
-    fn is_non_one(self: u8) -> bool {
-        self != U8Oneable::one()
-    }
-}
-
-impl U16Oneable of Oneable<u16> {
-    fn one() -> u16 {
-        1
-    }
-    #[inline(always)]
-    fn is_one(self: u16) -> bool {
-        self == U16Oneable::one()
-    }
-    #[inline(always)]
-    fn is_non_one(self: u16) -> bool {
-        self != U16Oneable::one()
-    }
-}
-
-impl U32Oneable of Oneable<u32> {
-    fn one() -> u32 {
-        1
-    }
-    #[inline(always)]
-    fn is_one(self: u32) -> bool {
-        self == U32Oneable::one()
-    }
-    #[inline(always)]
-    fn is_non_one(self: u32) -> bool {
-        self != U32Oneable::one()
-    }
-}
-
-impl U64Oneable of Oneable<u64> {
-    fn one() -> u64 {
-        1
-    }
-    #[inline(always)]
-    fn is_one(self: u64) -> bool {
-        self == U64Oneable::one()
-    }
-    #[inline(always)]
-    fn is_non_one(self: u64) -> bool {
-        self != U64Oneable::one()
-    }
-}
-
-impl U128Oneable of Oneable<u128> {
-    fn one() -> u128 {
-        1
-    }
-    #[inline(always)]
-    fn is_one(self: u128) -> bool {
-        self == U128Oneable::one()
-    }
-    #[inline(always)]
-    fn is_non_one(self: u128) -> bool {
-        self != U128Oneable::one()
+pub(crate) mod one_based {
+    pub(crate) impl OneableImpl<
+        T, impl OneImpl: core::num::traits::One<T>, +Drop<T>, +Copy<T>
+    > of super::Oneable<T> {
+        fn one() -> T {
+            OneImpl::one()
+        }
+        #[inline(always)]
+        fn is_one(self: T) -> bool {
+            OneImpl::is_one(@self)
+        }
+        #[inline(always)]
+        fn is_non_one(self: T) -> bool {
+            OneImpl::is_non_one(@self)
+        }
     }
 }
 
-impl U256Oneable of Oneable<u256> {
-    fn one() -> u256 {
-        1
-    }
-    #[inline(always)]
-    fn is_one(self: u256) -> bool {
-        self == U256Oneable::one()
-    }
-    #[inline(always)]
-    fn is_non_one(self: u256) -> bool {
-        self != U256Oneable::one()
-    }
-}
+// Oneable impls
+impl U8Oneable = math::one_based::OneableImpl<u8>;
+impl U16Oneable = math::one_based::OneableImpl<u16>;
+impl U32Oneable = math::one_based::OneableImpl<u32>;
+impl U64Oneable = math::one_based::OneableImpl<u64>;
+impl U128Oneable = math::one_based::OneableImpl<u128>;
+impl U256Oneable = math::one_based::OneableImpl<u256>;
diff --git a/corelib/src/metaprogramming.cairo b/corelib/src/metaprogramming.cairo
new file mode 100644
index 0000000..87ed62e
--- /dev/null
+++ b/corelib/src/metaprogramming.cairo
@@ -0,0 +1,5 @@
+/// A trait that can be used to disable implementations based on the types of the generic args.
+/// Assumes that `TypeEqualImpl` is the only implementation of this trait.
+pub trait TypeEqual<S, T> {}
+
+impl TypeEqualImpl<T> of TypeEqual<T, T>;
diff --git a/corelib/src/nullable.cairo b/corelib/src/nullable.cairo
index a7a35fd..5f2c37b 100644
--- a/corelib/src/nullable.cairo
+++ b/corelib/src/nullable.cairo
@@ -1,38 +1,53 @@
-use box::BoxTrait;
-use traits::Default;
-use traits::Felt252DictValue;
+use core::box::BoxTrait;
+use core::traits::Default;
+use core::traits::Felt252DictValue;
 
 #[derive(Copy, Drop)]
-extern type Nullable<T>;
+pub extern type Nullable<T>;
 
-enum FromNullableResult<T> {
+pub enum FromNullableResult<T> {
     Null,
     NotNull: Box<T>,
 }
 
-extern fn null<T>() -> Nullable<T> nopanic;
-extern fn nullable_from_box<T>(value: Box<T>) -> Nullable<T> nopanic;
-extern fn match_nullable<T>(value: Nullable<T>) -> FromNullableResult<T> nopanic;
+pub extern fn null<T>() -> Nullable<T> nopanic;
+pub(crate) extern fn nullable_from_box<T>(value: Box<T>) -> Nullable<T> nopanic;
+pub extern fn match_nullable<T>(value: Nullable<T>) -> FromNullableResult<T> nopanic;
+extern fn nullable_forward_snapshot<T>(value: @Nullable<T>) -> Nullable<@T> nopanic;
 
-trait NullableTrait<T> {
-    fn deref(self: Nullable<T>) -> T;
-    fn new(value: T) -> Nullable<T>;
-}
-
-impl NullableImpl<T> of NullableTrait<T> {
+#[generate_trait]
+pub impl NullableImpl<T> of NullableTrait<T> {
     fn deref(self: Nullable<T>) -> T {
         match match_nullable(self) {
-            FromNullableResult::Null => panic_with_felt252('Attempted to deref null value'),
+            FromNullableResult::Null => core::panic_with_felt252('Attempted to deref null value'),
             FromNullableResult::NotNull(value) => value.unbox(),
         }
     }
+    fn deref_or<+Drop<T>>(self: Nullable<T>, default: T) -> T {
+        match match_nullable(self) {
+            FromNullableResult::Null => default,
+            FromNullableResult::NotNull(value) => value.unbox(),
+        }
+    }
+    #[must_use]
     fn new(value: T) -> Nullable<T> {
         nullable_from_box(BoxTrait::new(value))
     }
+    #[must_use]
+    fn is_null(self: @Nullable<T>) -> bool {
+        match match_nullable(self.as_snapshot()) {
+            FromNullableResult::Null => true,
+            FromNullableResult::NotNull(_) => false,
+        }
+    }
+    fn as_snapshot(self: @Nullable<T>) -> Nullable<@T> nopanic {
+        nullable_forward_snapshot(self)
+    }
 }
 
 impl NullableDefault<T> of Default<Nullable<T>> {
     #[inline(always)]
+    #[must_use]
     fn default() -> Nullable<T> nopanic {
         null()
     }
@@ -40,7 +55,20 @@ impl NullableDefault<T> of Default<Nullable<T>> {
 
 impl NullableFelt252DictValue<T> of Felt252DictValue<Nullable<T>> {
     #[inline(always)]
+    #[must_use]
     fn zero_default() -> Nullable<T> nopanic {
         null()
     }
 }
+
+impl NullableDebug<T, impl TDebug: core::fmt::Debug<T>> of core::fmt::Debug<Nullable<T>> {
+    fn fmt(self: @Nullable<T>, ref f: core::fmt::Formatter) -> Result<(), core::fmt::Error> {
+        match match_nullable(self.as_snapshot()) {
+            FromNullableResult::Null => write!(f, "null"),
+            FromNullableResult::NotNull(value) => {
+                write!(f, "&")?;
+                TDebug::fmt(value.unbox(), ref f)
+            },
+        }
+    }
+}
diff --git a/corelib/src/num.cairo b/corelib/src/num.cairo
new file mode 100644
index 0000000..f6ac8fc
--- /dev/null
+++ b/corelib/src/num.cairo
@@ -0,0 +1 @@
+pub mod traits;
diff --git a/corelib/src/num/traits.cairo b/corelib/src/num/traits.cairo
new file mode 100644
index 0000000..75f57a4
--- /dev/null
+++ b/corelib/src/num/traits.cairo
@@ -0,0 +1,8 @@
+pub mod zero;
+pub use zero::Zero;
+
+pub mod one;
+pub use one::One;
+
+pub mod bit_size;
+pub use bit_size::BitSize;
diff --git a/corelib/src/num/traits/bit_size.cairo b/corelib/src/num/traits/bit_size.cairo
new file mode 100644
index 0000000..76d50a4
--- /dev/null
+++ b/corelib/src/num/traits/bit_size.cairo
@@ -0,0 +1,6 @@
+/// Trait used to retrieve the size in bits of a type.
+pub trait BitSize<T> {
+    /// Returns the size in bits of T as usize.
+    #[must_use]
+    fn bits() -> usize;
+}
diff --git a/corelib/src/num/traits/one.cairo b/corelib/src/num/traits/one.cairo
new file mode 100644
index 0000000..34ff7a0
--- /dev/null
+++ b/corelib/src/num/traits/one.cairo
@@ -0,0 +1,9 @@
+/// Defines a multiplicative identity element for `T`.
+pub trait One<T> {
+    /// Returns the multiplicative identity element of `T`, `1`.
+    fn one() -> T;
+    /// Returns `true` if `self` is equal to the multiplicative identity.
+    fn is_one(self: @T) -> bool;
+    /// Returns `false` if `self` is equal to the multiplicative identity.
+    fn is_non_one(self: @T) -> bool;
+}
diff --git a/corelib/src/num/traits/zero.cairo b/corelib/src/num/traits/zero.cairo
new file mode 100644
index 0000000..c43bd5d
--- /dev/null
+++ b/corelib/src/num/traits/zero.cairo
@@ -0,0 +1,9 @@
+/// Defines an additive identity element for `T`.
+pub trait Zero<T> {
+    /// Returns the additive identity element of `T`, `0`.
+    fn zero() -> T;
+    /// Returns `true` if `self` is equal to the additive identity.
+    fn is_zero(self: @T) -> bool;
+    /// Returns `false` if `self` is equal to the additive identity.
+    fn is_non_zero(self: @T) -> bool;
+}
diff --git a/corelib/src/option.cairo b/corelib/src/option.cairo
index 79672c5..6db7b30 100644
--- a/corelib/src/option.cairo
+++ b/corelib/src/option.cairo
@@ -1,35 +1,62 @@
-use array::ArrayTrait;
-use serde::Serde;
-use array::SpanTrait;
-
-#[derive(Copy, Drop, Serde, PartialEq)]
-enum Option<T> {
+#[must_use]
+#[derive(Copy, Drop, Debug, Serde, PartialEq)]
+pub enum Option<T> {
     Some: T,
     None,
 }
 
-trait OptionTrait<T> {
+pub impl DestructOption<T, +Destruct<T>, -Drop<Option<T>>> of Destruct<Option<T>> {
+    #[inline(always)]
+    fn destruct(self: Option<T>) nopanic {
+        match self {
+            Option::Some(x) => x.destruct(),
+            Option::None => (),
+        };
+    }
+}
+
+pub trait OptionTrait<T> {
     /// If `val` is `Option::Some(x)`, returns `x`. Otherwise, panics with `err`.
     fn expect(self: Option<T>, err: felt252) -> T;
     /// If `val` is `Option::Some(x)`, returns `x`. Otherwise, panics.
     fn unwrap(self: Option<T>) -> T;
+    /// Transforms the `Option<T>` into a `Result<T, E>`, mapping `Option::Some(v)` to
+    /// `Result::Ok(v)` and `Option::None` to `Result::Err(err)`.
+    fn ok_or<E, +Drop<E>>(self: Option<T>, err: E) -> Result<T, E>;
     /// Returns `true` if the `Option` is `Option::Some`.
+    #[must_use]
     fn is_some(self: @Option<T>) -> bool;
     /// Returns `true` if the `Option` is `Option::None`.
+    #[must_use]
     fn is_none(self: @Option<T>) -> bool;
+    /// If `self` is `Option::Some(x)`, returns `x`. Otherwise, returns the provided default.
+    fn unwrap_or<+Drop<T>>(self: Option<T>, default: T) -> T;
+    /// If `self` is `Option::Some(x)`, returns `x`. Otherwise, returns `Default::<T>::default()`.
+    fn unwrap_or_default<+Default<T>>(self: Option<T>) -> T;
 }
-impl OptionTraitImpl<T> of OptionTrait<T> {
+
+pub impl OptionTraitImpl<T> of OptionTrait<T> {
     #[inline(always)]
     fn expect(self: Option<T>, err: felt252) -> T {
         match self {
             Option::Some(x) => x,
-            Option::None => panic_with_felt252(err),
+            Option::None => core::panic_with_felt252(err),
         }
     }
+
     #[inline(always)]
     fn unwrap(self: Option<T>) -> T {
         self.expect('Option::unwrap failed.')
     }
+
+    #[inline]
+    fn ok_or<E, +Drop<E>>(self: Option<T>, err: E) -> Result<T, E> {
+        match self {
+            Option::Some(v) => Result::Ok(v),
+            Option::None => Result::Err(err),
+        }
+    }
+
     #[inline(always)]
     fn is_some(self: @Option<T>) -> bool {
         match self {
@@ -37,6 +64,7 @@ impl OptionTraitImpl<T> of OptionTrait<T> {
             Option::None => false,
         }
     }
+
     #[inline(always)]
     fn is_none(self: @Option<T>) -> bool {
         match self {
@@ -44,4 +72,20 @@ impl OptionTraitImpl<T> of OptionTrait<T> {
             Option::None => true,
         }
     }
+
+    #[inline]
+    fn unwrap_or<+Drop<T>>(self: Option<T>, default: T) -> T {
+        match self {
+            Option::Some(x) => x,
+            Option::None => default,
+        }
+    }
+
+    #[inline]
+    fn unwrap_or_default<+Default<T>>(self: Option<T>) -> T {
+        match self {
+            Option::Some(x) => x,
+            Option::None => Default::default(),
+        }
+    }
 }
diff --git a/corelib/src/panics.cairo b/corelib/src/panics.cairo
index 1541a81..c6b49cc 100644
--- a/corelib/src/panics.cairo
+++ b/corelib/src/panics.cairo
@@ -1,10 +1,19 @@
-use array::Array;
+use core::array::Array;
 
-struct Panic {}
+pub struct Panic {}
 
-enum PanicResult<T> {
+pub enum PanicResult<T> {
     Ok: T,
     Err: (Panic, Array<felt252>),
 }
 
-extern fn panic(data: Array<felt252>) -> never;
+pub extern fn panic(data: Array<felt252>) -> core::never;
+
+/// Panics with the given ByteArray. That is, panics with an `Array<felt252>` with
+/// `BYTE_ARRAY_MAGIC`, and then the serialized given ByteArray.
+#[inline(always)]
+pub fn panic_with_byte_array(err: @ByteArray) -> core::never {
+    let mut serialized = array![core::byte_array::BYTE_ARRAY_MAGIC];
+    err.serialize(ref serialized);
+    panic(serialized)
+}
diff --git a/corelib/src/pedersen.cairo b/corelib/src/pedersen.cairo
index 11f9129..8a5bf72 100644
--- a/corelib/src/pedersen.cairo
+++ b/corelib/src/pedersen.cairo
@@ -1,16 +1,16 @@
-extern type Pedersen;
+pub extern type Pedersen;
 
-extern fn pedersen(a: felt252, b: felt252) -> felt252 implicits(Pedersen) nopanic;
+pub extern fn pedersen(a: felt252, b: felt252) -> felt252 implicits(Pedersen) nopanic;
 
 
 /// State for Pedersen hash.
-#[derive(Copy, Drop)]
-struct HashState {
-    state: felt252,
+#[derive(Copy, Drop, Debug)]
+pub struct HashState {
+    pub state: felt252,
 }
 
 #[generate_trait]
-impl PedersenImpl of PedersenTrait {
+pub impl PedersenImpl of PedersenTrait {
     /// Creates a state from a base value.
     #[inline(always)]
     fn new(base: felt252) -> HashState {
@@ -18,7 +18,7 @@ impl PedersenImpl of PedersenTrait {
     }
 }
 
-impl HashStateImpl of hash::HashStateTrait<HashState> {
+impl HashStateImpl of core::hash::HashStateTrait<HashState> {
     #[inline(always)]
     fn update(self: HashState, value: felt252) -> HashState {
         HashState { state: pedersen(self.state, value) }
diff --git a/corelib/src/poseidon.cairo b/corelib/src/poseidon.cairo
index 360e8f8..9540160 100644
--- a/corelib/src/poseidon.cairo
+++ b/corelib/src/poseidon.cairo
@@ -1,25 +1,25 @@
-use array::Span;
-use array::SpanTrait;
-use option::OptionTrait;
-use hash::HashStateTrait;
+use core::array::Span;
+use core::array::SpanTrait;
+use core::option::OptionTrait;
+use core::hash::HashStateTrait;
 
-extern type Poseidon;
+pub extern type Poseidon;
 
-extern fn hades_permutation(
+pub extern fn hades_permutation(
     s0: felt252, s1: felt252, s2: felt252
 ) -> (felt252, felt252, felt252) implicits(Poseidon) nopanic;
 
 /// State for Poseidon hash.
-#[derive(Copy, Drop)]
-struct HashState {
-    s0: felt252,
-    s1: felt252,
-    s2: felt252,
-    odd: bool,
+#[derive(Copy, Drop, Debug)]
+pub struct HashState {
+    pub s0: felt252,
+    pub s1: felt252,
+    pub s2: felt252,
+    pub odd: bool,
 }
 
 #[generate_trait]
-impl PoseidonImpl of PoseidonTrait {
+pub impl PoseidonImpl of PoseidonTrait {
     /// Creates an initial state.
     #[inline(always)]
     fn new() -> HashState {
@@ -62,28 +62,26 @@ impl HashStateImpl of HashStateTrait<HashState> {
 /// To distinguish between use cases, the capacity element is initialized to 0.
 /// To distinguish between different input sizes always pads with 1, and possibly with another 0 to
 /// complete to an even-sized input.
-fn poseidon_hash_span(mut span: Span<felt252>) -> felt252 {
-    _poseidon_hash_span_inner(get_builtin_costs(), (0, 0, 0), ref span)
+pub fn poseidon_hash_span(mut span: Span<felt252>) -> felt252 {
+    _poseidon_hash_span_inner(core::gas::get_builtin_costs(), (0, 0, 0), ref span)
 }
 
 /// Helper function for poseidon_hash_span.
 fn _poseidon_hash_span_inner(
-    builtin_costs: gas::BuiltinCosts, state: (felt252, felt252, felt252), ref span: Span<felt252>
+    builtin_costs: core::gas::BuiltinCosts,
+    state: (felt252, felt252, felt252),
+    ref span: Span<felt252>
 ) -> felt252 {
     let (s0, s1, s2) = state;
     let x = *match span.pop_front() {
         Option::Some(x) => x,
-        Option::None => {
-            return HashState { s0, s1, s2, odd: false }.finalize();
-        },
+        Option::None => { return HashState { s0, s1, s2, odd: false }.finalize(); },
     };
     let y = *match span.pop_front() {
         Option::Some(y) => y,
-        Option::None => {
-            return HashState { s0: s0 + x, s1, s2, odd: true }.finalize();
-        },
+        Option::None => { return HashState { s0: s0 + x, s1, s2, odd: true }.finalize(); },
     };
     let next_state = hades_permutation(s0 + x, s1 + y, s2);
-    gas::withdraw_gas_all(builtin_costs).expect('Out of gas');
+    core::gas::withdraw_gas_all(builtin_costs).expect('Out of gas');
     _poseidon_hash_span_inner(builtin_costs, next_state, ref span)
 }
diff --git a/corelib/src/prelude.cairo b/corelib/src/prelude.cairo
new file mode 100644
index 0000000..c82d932
--- /dev/null
+++ b/corelib/src/prelude.cairo
@@ -0,0 +1,2 @@
+mod v2023_01;
+mod v2023_10;
diff --git a/corelib/src/prelude/v2023_01.cairo b/corelib/src/prelude/v2023_01.cairo
new file mode 100644
index 0000000..d2bf4f2
--- /dev/null
+++ b/corelib/src/prelude/v2023_01.cairo
@@ -0,0 +1,70 @@
+use core::{
+    BoolBitAnd, BoolBitOr, BoolBitXor, BoolFelt252DictValue, BoolIntoFelt252, BoolNot,
+    BoolPartialEq, BoolSerde, Felt252Add, Felt252AddEq, Felt252Default, Felt252Felt252DictValue,
+    Felt252Mul, Felt252MulEq, Felt252Neg, Felt252PartialEq, Felt252Serde, Felt252Sub, Felt252SubEq,
+    Felt252TryIntoNonZero, RangeCheck, SegmentArena, assert, bool, bool_and_impl, bool_not_impl,
+    bool_or_impl, bool_to_felt252, bool_xor_impl, drop, dup, felt252, felt252_add, felt252_const,
+    felt252_div, felt252_is_zero, felt252_mul, felt252_sub, never, panic_with_felt252, usize
+};
+
+use core::{array, array::{Array, ArrayTrait, Span, SpanTrait}};
+use core::{box, box::{Box, BoxTrait}};
+use core::{
+    bytes_31,
+    bytes_31::{
+        Bytes31IndexView, Bytes31IntoFelt252, Bytes31Trait, Felt252TryIntoBytes31, bytes31,
+        bytes31_const
+    }
+};
+use core::{
+    byte_array, byte_array::{ByteArray, ByteArrayIndexView, ByteArrayStringLiteral, ByteArrayTrait}
+};
+use core::{clone, clone::Clone};
+use core::cmp;
+use core::debug;
+use core::{
+    dict,
+    dict::{
+        Felt252Dict, Felt252DictTrait, SquashedFelt252Dict, felt252_dict_new, felt252_dict_squash
+    }
+};
+use core::{ec, ec::{EcOp, EcPoint, EcState}};
+use core::ecdsa;
+use core::{gas, gas::{BuiltinCosts, GasBuiltin, get_builtin_costs}};
+use core::hash;
+use core::{
+    integer,
+    integer::{
+        Bitwise, Felt252IntoU256, Felt252TryIntoU128, Felt252TryIntoU16, Felt252TryIntoU32,
+        Felt252TryIntoU64, Felt252TryIntoU8, I128IntoFelt252, I16IntoFelt252, I32IntoFelt252,
+        I64IntoFelt252, I8IntoFelt252, NumericLiteral, U128IntoFelt252, U16IntoFelt252,
+        U32IntoFelt252, U64IntoFelt252, U8IntoFelt252, i128, i16, i32, i64, i8, u128, u128_is_zero,
+        u128_sqrt, u16, u256, u256_sqrt, u32, u64, u8
+    }
+};
+use core::internal;
+use core::keccak;
+use core::math;
+use core::{nullable, nullable::{Nullable, NullableTrait, match_nullable, null, nullable_from_box}};
+use core::{option, option::{Option, OptionTrait}};
+use core::{panics, panics::{Panic, PanicResult, panic}};
+use core::{pedersen, pedersen::Pedersen};
+use core::{poseidon, poseidon::Poseidon};
+use core::{result, result::{Result, ResultTrait}};
+use core::{serde, serde::Serde};
+use core::{starknet, starknet::System};
+use core::{string, string::StringLiteral};
+use core::testing;
+use core::to_byte_array;
+use core::{
+    traits,
+    traits::{
+        Add, AddEq, BitAnd, BitNot, BitOr, BitXor, Copy, Default, Destruct, Div, DivEq, DivRem,
+        Drop, Felt252DictValue, Index, IndexView, Into, Mul, MulEq, Neg, Not, PanicDestruct,
+        PartialEq, PartialOrd, Rem, RemEq, Sub, SubEq, TryInto, TupleSize0Copy, TupleSize0Drop
+    }
+};
+use core::{zeroable, zeroable::{NonZero, Zeroable}};
+
+#[cfg(test)]
+use core::test;
diff --git a/corelib/src/prelude/v2023_10.cairo b/corelib/src/prelude/v2023_10.cairo
new file mode 100644
index 0000000..61e714d
--- /dev/null
+++ b/corelib/src/prelude/v2023_10.cairo
@@ -0,0 +1,27 @@
+pub use core::{RangeCheck, SegmentArena, assert, bool, felt252, usize};
+
+pub use core::array::{Array, ArrayTrait, Span, SpanTrait};
+pub use core::box::{Box, BoxTrait};
+pub use core::bytes_31::{Bytes31Trait, bytes31};
+pub use core::byte_array::{ByteArray, ByteArrayTrait};
+pub use core::clone::Clone;
+pub use core::dict::{Felt252Dict, Felt252DictTrait, SquashedFelt252Dict};
+pub use core::gas::GasBuiltin;
+pub use core::integer::{Bitwise, i128, i16, i32, i64, i8, u128, u16, u256, u32, u64, u8};
+pub use core::keccak;
+pub use core::math;
+pub use core::nullable::{Nullable, NullableTrait};
+pub use core::option::{Option, OptionTrait};
+pub use core::panics::{Panic, PanicResult, panic};
+pub use core::pedersen::Pedersen;
+pub use core::poseidon::Poseidon;
+pub use core::result::{Result, ResultTrait};
+pub use core::serde::Serde;
+pub use core::{starknet, starknet::System};
+pub use core::to_byte_array;
+pub use core::traits::{
+    Add, AddEq, BitAnd, BitNot, BitOr, BitXor, Copy, Default, Destruct, Div, DivEq, DivRem, Drop,
+    Felt252DictValue, Index, IndexView, Into, Mul, MulEq, Neg, Not, PanicDestruct, PartialEq,
+    PartialOrd, Rem, RemEq, Sub, SubEq, TryInto
+};
+pub use core::zeroable::NonZero;
diff --git a/corelib/src/result.cairo b/corelib/src/result.cairo
index 6c0b5c8..b9eb9aa 100644
--- a/corelib/src/result.cairo
+++ b/corelib/src/result.cairo
@@ -1,35 +1,52 @@
-use array::ArrayTrait;
-use serde::Serde;
-use array::SpanTrait;
+use core::array::ArrayTrait;
+use core::serde::Serde;
+use core::array::SpanTrait;
 
-#[derive(Copy, Drop, Serde, PartialEq)]
-enum Result<T, E> {
+#[must_use]
+#[derive(Copy, Drop, Debug, Serde, PartialEq)]
+pub enum Result<T, E> {
     Ok: T,
     Err: E,
 }
 
 #[generate_trait]
-impl ResultTraitImpl<T, E> of ResultTrait<T, E> {
+pub impl ResultTraitImpl<T, E> of ResultTrait<T, E> {
     /// If `val` is `Result::Ok(x)`, returns `x`. Otherwise, panics with `err`.
-    fn expect<impl EDrop: Drop<E>>(self: Result<T, E>, err: felt252) -> T {
+    fn expect<+Drop<E>>(self: Result<T, E>, err: felt252) -> T {
         match self {
             Result::Ok(x) => x,
-            Result::Err(_) => panic_with_felt252(err),
+            Result::Err(_) => core::panic_with_felt252(err),
         }
     }
     /// If `val` is `Result::Ok(x)`, returns `x`. Otherwise, panics.
-    fn unwrap<impl EDrop: Drop<E>>(self: Result<T, E>) -> T {
+    fn unwrap<+Drop<E>>(self: Result<T, E>) -> T {
         self.expect('Result::unwrap failed.')
     }
+    /// If `val` is `Result::Ok(x)`, returns `x`. Otherwise, returns `default`.
+    fn unwrap_or<+Drop<T>, +Drop<E>>(self: Result<T, E>, default: T) -> T {
+        match self {
+            Result::Ok(x) => x,
+            Result::Err(_) => default,
+        }
+    }
+    /// If `val` is `Result::Ok(x)`, returns `x`.
+    /// Otherwise returns `Default::<T>::default()`.
+    fn unwrap_or_default<+Drop<E>, +Default<T>>(self: Result<T, E>) -> T {
+        match self {
+            Result::Ok(x) => x,
+            Result::Err(_) => Default::default(),
+        }
+    }
+
     /// If `val` is `Result::Err(x)`, returns `x`. Otherwise, panics with `err`.
-    fn expect_err<impl TDrop: Drop<T>>(self: Result<T, E>, err: felt252) -> E {
+    fn expect_err<+Drop<T>>(self: Result<T, E>, err: felt252) -> E {
         match self {
-            Result::Ok(_) => panic_with_felt252(err),
+            Result::Ok(_) => core::panic_with_felt252(err),
             Result::Err(x) => x,
         }
     }
     /// If `val` is `Result::Err(x)`, returns `x`. Otherwise, panics.
-    fn unwrap_err<impl TDrop: Drop<T>>(self: Result<T, E>) -> E {
+    fn unwrap_err<+Drop<T>>(self: Result<T, E>) -> E {
         self.expect_err('Result::unwrap_err failed.')
     }
     /// Returns `true` if the `Result` is `Result::Ok`.
@@ -50,7 +67,7 @@ impl ResultTraitImpl<T, E> of ResultTrait<T, E> {
     }
     /// Returns `true` if the `Result` is `Result::Ok`, and consumes the value.
     #[inline]
-    fn into_is_err<impl TDrop: Drop<T>, impl EDrop: Drop<E>>(self: Result<T, E>) -> bool {
+    fn into_is_err<+Drop<T>, +Drop<E>>(self: Result<T, E>) -> bool {
         match self {
             Result::Ok(_) => false,
             Result::Err(_) => true,
@@ -58,7 +75,7 @@ impl ResultTraitImpl<T, E> of ResultTrait<T, E> {
     }
     /// Returns `true` if the `Result` is `Result::Err`, and consumes the value.
     #[inline]
-    fn into_is_ok<impl TDrop: Drop<T>, impl EDrop: Drop<E>>(self: Result<T, E>) -> bool {
+    fn into_is_ok<+Drop<T>, +Drop<E>>(self: Result<T, E>) -> bool {
         match self {
             Result::Ok(_) => true,
             Result::Err(_) => false,
diff --git a/corelib/src/serde.cairo b/corelib/src/serde.cairo
index 9d1891a..98b0419 100644
--- a/corelib/src/serde.cairo
+++ b/corelib/src/serde.cairo
@@ -1,9 +1,7 @@
-use array::ArrayTrait;
-use array::SpanTrait;
-use traits::Into;
-use traits::TryInto;
+use core::array::ArrayTrait;
+use core::array::SpanTrait;
 
-trait Serde<T> {
+pub trait Serde<T> {
     fn serialize(self: @T, ref output: Array<felt252>);
     fn deserialize(ref serialized: Span<felt252>) -> Option<T>;
 }
@@ -15,44 +13,29 @@ impl TupleSize0Serde of Serde<()> {
     }
 }
 
-impl TupleSize1Serde<E0, impl E0Serde: Serde<E0>> of Serde<(E0,)> {
+impl TupleSize1Serde<E0, +Serde<E0>> of Serde<(E0,)> {
     fn serialize(self: @(E0,), ref output: Array<felt252>) {
         let (e0,) = self;
         e0.serialize(ref output)
     }
     fn deserialize(ref serialized: Span<felt252>) -> Option<(E0,)> {
-        Option::Some((E0Serde::deserialize(ref serialized)?,))
+        Option::Some((Serde::deserialize(ref serialized)?,))
     }
 }
 
-impl TupleSize2Serde<
-    E0,
-    E1,
-    impl E0Serde: Serde<E0>,
-    impl E0Drop: Drop<E0>,
-    impl E1Serde: Serde<E1>,
-    impl E0Drop: Drop<E1>
-> of Serde<(E0, E1)> {
+impl TupleSize2Serde<E0, E1, +Serde<E0>, +Drop<E0>, +Serde<E1>, +Drop<E1>> of Serde<(E0, E1)> {
     fn serialize(self: @(E0, E1), ref output: Array<felt252>) {
         let (e0, e1) = self;
         e0.serialize(ref output);
         e1.serialize(ref output)
     }
     fn deserialize(ref serialized: Span<felt252>) -> Option<(E0, E1)> {
-        Option::Some((E0Serde::deserialize(ref serialized)?, E1Serde::deserialize(ref serialized)?))
+        Option::Some((Serde::deserialize(ref serialized)?, Serde::deserialize(ref serialized)?))
     }
 }
 
 impl TupleSize3Serde<
-    E0,
-    E1,
-    E2,
-    impl E0Serde: Serde<E0>,
-    impl E0Drop: Drop<E0>,
-    impl E1Serde: Serde<E1>,
-    impl E1Drop: Drop<E1>,
-    impl E2Serde: Serde<E2>,
-    impl E2Drop: Drop<E2>
+    E0, E1, E2, +Serde<E0>, +Drop<E0>, +Serde<E1>, +Drop<E1>, +Serde<E2>, +Drop<E2>
 > of Serde<(E0, E1, E2)> {
     fn serialize(self: @(E0, E1, E2), ref output: Array<felt252>) {
         let (e0, e1, e2) = self;
@@ -63,9 +46,9 @@ impl TupleSize3Serde<
     fn deserialize(ref serialized: Span<felt252>) -> Option<(E0, E1, E2)> {
         Option::Some(
             (
-                E0Serde::deserialize(ref serialized)?,
-                E1Serde::deserialize(ref serialized)?,
-                E2Serde::deserialize(ref serialized)?
+                Serde::deserialize(ref serialized)?,
+                Serde::deserialize(ref serialized)?,
+                Serde::deserialize(ref serialized)?
             )
         )
     }
@@ -76,14 +59,14 @@ impl TupleSize4Serde<
     E1,
     E2,
     E3,
-    impl E0Serde: Serde<E0>,
-    impl E0Drop: Drop<E0>,
-    impl E1Serde: Serde<E1>,
-    impl E1Drop: Drop<E1>,
-    impl E2Serde: Serde<E2>,
-    impl E2Drop: Drop<E2>,
-    impl E3Serde: Serde<E3>,
-    impl E3Drop: Drop<E3>
+    +Serde<E0>,
+    +Drop<E0>,
+    +Serde<E1>,
+    +Drop<E1>,
+    +Serde<E2>,
+    +Drop<E2>,
+    +Serde<E3>,
+    +Drop<E3>
 > of Serde<(E0, E1, E2, E3)> {
     fn serialize(self: @(E0, E1, E2, E3), ref output: Array<felt252>) {
         let (e0, e1, e2, e3) = self;
@@ -95,11 +78,31 @@ impl TupleSize4Serde<
     fn deserialize(ref serialized: Span<felt252>) -> Option<(E0, E1, E2, E3)> {
         Option::Some(
             (
-                E0Serde::deserialize(ref serialized)?,
-                E1Serde::deserialize(ref serialized)?,
-                E2Serde::deserialize(ref serialized)?,
-                E3Serde::deserialize(ref serialized)?
+                Serde::deserialize(ref serialized)?,
+                Serde::deserialize(ref serialized)?,
+                Serde::deserialize(ref serialized)?,
+                Serde::deserialize(ref serialized)?
             )
         )
     }
 }
+
+/// Impl for `Serde` for types that can be converted into `felt252` using the `Into` trait and from `felt252` using the `TryInto` trait.
+/// Usage example:
+/// ```ignore
+/// impl MyTypeSerde = core::serde::into_felt252_based::SerdeImpl<MyType>;`
+/// ```
+pub mod into_felt252_based {
+    use core::traits::{Into, TryInto};
+    use core::array::ArrayTrait;
+    pub impl SerdeImpl<T, +Copy<T>, +Into<T, felt252>, +TryInto<felt252, T>> of super::Serde<T> {
+        #[inline(always)]
+        fn serialize(self: @T, ref output: Array<felt252>) {
+            output.append((*self).into());
+        }
+        #[inline(always)]
+        fn deserialize(ref serialized: Span<felt252>) -> Option<T> {
+            Option::Some((*serialized.pop_front()?).try_into()?)
+        }
+    }
+}
diff --git a/corelib/src/starknet.cairo b/corelib/src/starknet.cairo
index 21d3791..f556235 100644
--- a/corelib/src/starknet.cairo
+++ b/corelib/src/starknet.cairo
@@ -1,22 +1,22 @@
-use box::Box;
-use option::OptionTrait;
-use array::Span;
-use traits::Into;
-use traits::TryInto;
-use zeroable::Zeroable;
+use core::box::Box;
+use core::option::OptionTrait;
+use core::array::Span;
+use core::traits::Into;
+use core::traits::TryInto;
+use core::zeroable::Zeroable;
 
 // Re-imports
 // Store
-mod storage_access;
+pub mod storage_access;
+pub use storage_access::{Store, StorageAddress};
 use storage_access::{
-    Store, StorePacking, StorageAddress, StorageBaseAddress, storage_base_address_const,
-    storage_base_address_from_felt252, storage_address_from_base,
-    storage_address_from_base_and_offset, storage_address_to_felt252,
+    StorePacking, StorageBaseAddress, storage_base_address_const, storage_base_address_from_felt252,
+    storage_address_from_base, storage_address_from_base_and_offset, storage_address_to_felt252,
     storage_address_try_from_felt252
 };
 
 // Module containing all the extern declaration of the syscalls.
-mod syscalls;
+pub mod syscalls;
 use syscalls::{
     call_contract_syscall, deploy_syscall, emit_event_syscall, get_block_hash_syscall,
     get_execution_info_syscall, library_call_syscall, send_message_to_l1_syscall,
@@ -24,51 +24,61 @@ use syscalls::{
 };
 
 // secp256
-mod secp256_trait;
-mod secp256k1;
-mod secp256r1;
+pub mod secp256_trait;
+pub mod secp256k1;
+pub mod secp256r1;
 
 // ContractAddress
-mod contract_address;
+pub mod contract_address;
+pub use contract_address::{ContractAddress, contract_address_const};
 use contract_address::{
-    ContractAddress, ContractAddressIntoFelt252, Felt252TryIntoContractAddress,
-    contract_address_const, contract_address_to_felt252, contract_address_try_from_felt252
+    ContractAddressIntoFelt252, Felt252TryIntoContractAddress, contract_address_to_felt252,
+    contract_address_try_from_felt252
 };
 
 // EthAddress
-mod eth_address;
+pub mod eth_address;
+pub use eth_address::EthAddress;
 use eth_address::{
-    EthAddress, EthAddressIntoFelt252, EthAddressSerde, EthAddressZeroable, Felt252TryIntoEthAddress
+    EthAddressIntoFelt252, EthAddressSerde, EthAddressZeroable, Felt252TryIntoEthAddress
 };
 
+// EthSignature
+pub mod eth_signature;
+use eth_signature::verify_eth_signature;
+
 // ClassHash
-mod class_hash;
+pub mod class_hash;
+pub use class_hash::ClassHash;
 use class_hash::{
-    ClassHash, ClassHashIntoFelt252, Felt252TryIntoClassHash, class_hash_const,
-    class_hash_to_felt252, class_hash_try_from_felt252
+    ClassHashIntoFelt252, Felt252TryIntoClassHash, class_hash_const, class_hash_to_felt252,
+    class_hash_try_from_felt252
 };
 
+// Not `pub` on purpose, only used for direct reexport by the next line.
 mod info;
-use info::{
-    ExecutionInfo, BlockInfo, TxInfo, get_execution_info, get_caller_address, get_contract_address,
-    get_block_info, get_tx_info, get_block_timestamp
+pub use info::{
+    v2::ExecutionInfo as ExecutionInfo, BlockInfo, v2::TxInfo as TxInfo, get_execution_info,
+    get_caller_address, get_contract_address, get_block_info, get_tx_info, get_block_timestamp
 };
 
-mod event;
-use event::Event;
+pub mod event;
+pub use event::Event;
+
+pub mod account;
+pub use account::AccountContract;
 
-mod account;
-use account::AccountContract;
+pub mod storage;
 
-extern type System;
+pub extern type System;
 
 // An Helper function to force the inclusion of `System` in the list of implicits.
 fn use_system_implicit() implicits(System) {}
 
 /// The result type for a syscall.
-type SyscallResult<T> = Result<T, Array<felt252>>;
+pub type SyscallResult<T> = Result<T, Array<felt252>>;
 
-trait SyscallResultTrait<T> {
+pub trait SyscallResultTrait<T> {
     /// If `val` is `Result::Ok(x)`, returns `x`. Otherwise, panics with the revert reason.
     fn unwrap_syscall(self: SyscallResult<T>) -> T;
 }
@@ -82,7 +92,7 @@ impl SyscallResultTraitImpl<T> of SyscallResultTrait<T> {
 }
 
 /// The expected return value of the `__validate*__` functions of an accounted contract.
-const VALIDATED: felt252 = 'VALID';
+pub const VALIDATED: felt252 = 'VALID';
 
 // Module for starknet testing only.
-mod testing;
+pub mod testing;
diff --git a/corelib/src/starknet/account.cairo b/corelib/src/starknet/account.cairo
index 4765a71..121efff 100644
--- a/corelib/src/starknet/account.cairo
+++ b/corelib/src/starknet/account.cairo
@@ -1,14 +1,14 @@
 use starknet::ContractAddress;
 
-#[derive(Drop, Serde)]
-struct Call {
-    to: ContractAddress,
-    selector: felt252,
-    calldata: Array<felt252>
+#[derive(Drop, Serde, Debug)]
+pub struct Call {
+    pub to: ContractAddress,
+    pub selector: felt252,
+    pub calldata: Span<felt252>
 }
 
 #[starknet::interface]
-trait AccountContract<TContractState> {
+pub trait AccountContract<TContractState> {
     fn __validate_declare__(self: @TContractState, class_hash: felt252) -> felt252;
     fn __validate__(ref self: TContractState, calls: Array<Call>) -> felt252;
     fn __execute__(ref self: TContractState, calls: Array<Call>) -> Array<Span<felt252>>;
diff --git a/corelib/src/starknet/class_hash.cairo b/corelib/src/starknet/class_hash.cairo
index 5d52693..17cdf9f 100644
--- a/corelib/src/starknet/class_hash.cairo
+++ b/corelib/src/starknet/class_hash.cairo
@@ -1,50 +1,50 @@
-use zeroable::Zeroable;
-use serde::Serde;
+use core::serde::Serde;
+use core::hash::{Hash, HashStateTrait};
 
 #[derive(Copy, Drop)]
-extern type ClassHash;
+pub extern type ClassHash;
 
+pub extern fn class_hash_const<const address: felt252>() -> ClassHash nopanic;
+pub(crate) extern fn class_hash_to_felt252(address: ClassHash) -> felt252 nopanic;
 
-extern fn class_hash_const<const address: felt252>() -> ClassHash nopanic;
-extern fn class_hash_to_felt252(address: ClassHash) -> felt252 nopanic;
-
-extern fn class_hash_try_from_felt252(
+pub(crate) extern fn class_hash_try_from_felt252(
     address: felt252
 ) -> Option<ClassHash> implicits(RangeCheck) nopanic;
 
-impl Felt252TryIntoClassHash of TryInto<felt252, ClassHash> {
+pub(crate) impl Felt252TryIntoClassHash of TryInto<felt252, ClassHash> {
     fn try_into(self: felt252) -> Option<ClassHash> {
         class_hash_try_from_felt252(self)
     }
 }
-impl ClassHashIntoFelt252 of Into<ClassHash, felt252> {
+pub(crate) impl ClassHashIntoFelt252 of Into<ClassHash, felt252> {
     fn into(self: ClassHash) -> felt252 {
         class_hash_to_felt252(self)
     }
 }
 
-impl ClassHashZeroable of Zeroable<ClassHash> {
+impl ClassHashZero of core::num::traits::Zero<ClassHash> {
     fn zero() -> ClassHash {
         class_hash_const::<0>()
     }
     #[inline(always)]
-    fn is_zero(self: ClassHash) -> bool {
-        class_hash_to_felt252(self).is_zero()
+    fn is_zero(self: @ClassHash) -> bool {
+        core::num::traits::Zero::<felt252>::is_zero(@class_hash_to_felt252(*self))
     }
     #[inline(always)]
-    fn is_non_zero(self: ClassHash) -> bool {
+    fn is_non_zero(self: @ClassHash) -> bool {
         !self.is_zero()
     }
 }
 
-impl ClassHashSerde of serde::Serde<ClassHash> {
+pub(crate) impl ClassHashZeroable =
+    core::zeroable::zero_based::ZeroableImpl<ClassHash, ClassHashZero>;
+
+impl ClassHashSerde of Serde<ClassHash> {
     fn serialize(self: @ClassHash, ref output: Array<felt252>) {
         class_hash_to_felt252(*self).serialize(ref output);
     }
     fn deserialize(ref serialized: Span<felt252>) -> Option<ClassHash> {
-        Option::Some(
-            class_hash_try_from_felt252(serde::Serde::<felt252>::deserialize(ref serialized)?)?
-        )
+        Option::Some(class_hash_try_from_felt252(Serde::<felt252>::deserialize(ref serialized)?)?)
     }
 }
 
@@ -58,3 +58,8 @@ impl ClassHashPartialEq of PartialEq<ClassHash> {
         !(lhs == rhs)
     }
 }
+
+impl HashClassHash<S, +HashStateTrait<S>, +Drop<S>> =
+    core::hash::into_felt252_based::HashImpl<ClassHash, S>;
+
+impl DebugClassHash = core::fmt::into_felt252_based::DebugImpl<ClassHash>;
diff --git a/corelib/src/starknet/contract_address.cairo b/corelib/src/starknet/contract_address.cairo
index 1e36eb1..c4d7353 100644
--- a/corelib/src/starknet/contract_address.cairo
+++ b/corelib/src/starknet/contract_address.cairo
@@ -1,51 +1,54 @@
-use zeroable::Zeroable;
-use serde::Serde;
+use core::zeroable::Zeroable;
+use core::serde::Serde;
+use core::hash::{Hash, HashStateTrait};
 
 #[derive(Copy, Drop)]
-extern type ContractAddress;
+pub extern type ContractAddress;
 
 
-extern fn contract_address_const<const address: felt252>() -> ContractAddress nopanic;
-extern fn contract_address_to_felt252(address: ContractAddress) -> felt252 nopanic;
+pub extern fn contract_address_const<const address: felt252>() -> ContractAddress nopanic;
+pub(crate) extern fn contract_address_to_felt252(address: ContractAddress) -> felt252 nopanic;
 
-extern fn contract_address_try_from_felt252(
+pub(crate) extern fn contract_address_try_from_felt252(
     address: felt252
 ) -> Option<ContractAddress> implicits(RangeCheck) nopanic;
 
-impl Felt252TryIntoContractAddress of TryInto<felt252, ContractAddress> {
+pub(crate) impl Felt252TryIntoContractAddress of TryInto<felt252, ContractAddress> {
     fn try_into(self: felt252) -> Option<ContractAddress> {
         contract_address_try_from_felt252(self)
     }
 }
-impl ContractAddressIntoFelt252 of Into<ContractAddress, felt252> {
+pub(crate) impl ContractAddressIntoFelt252 of Into<ContractAddress, felt252> {
     fn into(self: ContractAddress) -> felt252 {
         contract_address_to_felt252(self)
     }
 }
 
-impl ContractAddressZeroable of Zeroable<ContractAddress> {
+
+impl ContractAddressZero of core::num::traits::Zero<ContractAddress> {
     fn zero() -> ContractAddress {
         contract_address_const::<0>()
     }
     #[inline(always)]
-    fn is_zero(self: ContractAddress) -> bool {
-        contract_address_to_felt252(self).is_zero()
+    fn is_zero(self: @ContractAddress) -> bool {
+        core::num::traits::Zero::<felt252>::is_zero(@contract_address_to_felt252(*self))
     }
     #[inline(always)]
-    fn is_non_zero(self: ContractAddress) -> bool {
+    fn is_non_zero(self: @ContractAddress) -> bool {
         !self.is_zero()
     }
 }
 
-impl ContractAddressSerde of serde::Serde<ContractAddress> {
+pub(crate) impl ContractAddressZeroable =
+    core::zeroable::zero_based::ZeroableImpl<ContractAddress, ContractAddressZero>;
+
+impl ContractAddressSerde of Serde<ContractAddress> {
     fn serialize(self: @ContractAddress, ref output: Array<felt252>) {
         contract_address_to_felt252(*self).serialize(ref output);
     }
     fn deserialize(ref serialized: Span<felt252>) -> Option<ContractAddress> {
         Option::Some(
-            contract_address_try_from_felt252(
-                serde::Serde::<felt252>::deserialize(ref serialized)?
-            )?
+            contract_address_try_from_felt252(Serde::<felt252>::deserialize(ref serialized)?)?
         )
     }
 }
@@ -60,3 +63,28 @@ impl ContractAddressPartialEq of PartialEq<ContractAddress> {
         !(lhs == rhs)
     }
 }
+
+impl ContractAddressPartialOrd of PartialOrd<ContractAddress> {
+    fn lt(lhs: ContractAddress, rhs: ContractAddress) -> bool {
+        // TODO(orizi): Check if implementing a libfunc for `felt252` ordering is more efficient.
+        let lhs: u256 = contract_address_to_felt252(lhs).into();
+        lhs < contract_address_to_felt252(rhs).into()
+    }
+    #[inline(always)]
+    fn le(lhs: ContractAddress, rhs: ContractAddress) -> bool {
+        !(rhs < lhs)
+    }
+    #[inline(always)]
+    fn gt(lhs: ContractAddress, rhs: ContractAddress) -> bool {
+        rhs < lhs
+    }
+    #[inline(always)]
+    fn ge(lhs: ContractAddress, rhs: ContractAddress) -> bool {
+        !(lhs < rhs)
+    }
+}
+
+impl HashContractAddress<S, +HashStateTrait<S>, +Drop<S>> =
+    core::hash::into_felt252_based::HashImpl<ContractAddress, S>;
+
+impl DebugContractAddress = core::fmt::into_felt252_based::DebugImpl<ContractAddress>;
diff --git a/corelib/src/starknet/eth_address.cairo b/corelib/src/starknet/eth_address.cairo
index 857bd4a..2053506 100644
--- a/corelib/src/starknet/eth_address.cairo
+++ b/corelib/src/starknet/eth_address.cairo
@@ -1,16 +1,15 @@
-use debug::PrintTrait;
-use integer::{u128_safe_divmod, U128TryIntoNonZero, U256TryIntoFelt252};
-use option::{Option, OptionTrait};
-use serde::Serde;
-use traits::{Into, TryInto};
-use zeroable::Zeroable;
+use core::debug::PrintTrait;
+use core::integer::{u128_safe_divmod, U128TryIntoNonZero, U256TryIntoFelt252};
+use core::option::{Option, OptionTrait};
+use core::serde::Serde;
+use core::traits::{Into, TryInto};
 
 // An Ethereum address (160 bits).
-#[derive(Copy, Drop, starknet::Store, PartialEq)]
-struct EthAddress {
+#[derive(Copy, Drop, Hash, PartialEq, starknet::Store)]
+pub struct EthAddress {
     address: felt252,
 }
-impl Felt252TryIntoEthAddress of TryInto<felt252, EthAddress> {
+pub(crate) impl Felt252TryIntoEthAddress of TryInto<felt252, EthAddress> {
     fn try_into(self: felt252) -> Option<EthAddress> {
         let ETH_ADDRESS_BOUND = 0x10000000000000000000000000000000000000000_u256; // 2 ** 160
 
@@ -21,12 +20,12 @@ impl Felt252TryIntoEthAddress of TryInto<felt252, EthAddress> {
         }
     }
 }
-impl EthAddressIntoFelt252 of Into<EthAddress, felt252> {
+pub(crate) impl EthAddressIntoFelt252 of Into<EthAddress, felt252> {
     fn into(self: EthAddress) -> felt252 {
         self.address
     }
 }
-impl U256IntoEthAddress of Into<u256, EthAddress> {
+pub(crate) impl U256IntoEthAddress of Into<u256, EthAddress> {
     fn into(self: u256) -> EthAddress {
         // The Ethereum address is the 20 least significant bytes (=160=128+32 bits) of the value.
         let high_32_bits = self.high % 0x100000000_u128;
@@ -36,7 +35,7 @@ impl U256IntoEthAddress of Into<u256, EthAddress> {
         }
     }
 }
-impl EthAddressSerde of Serde<EthAddress> {
+pub(crate) impl EthAddressSerde of Serde<EthAddress> {
     fn serialize(self: @EthAddress, ref output: Array<felt252>) {
         self.address.serialize(ref output);
     }
@@ -44,22 +43,27 @@ impl EthAddressSerde of Serde<EthAddress> {
         Serde::<felt252>::deserialize(ref serialized)?.try_into()
     }
 }
-impl EthAddressZeroable of Zeroable<EthAddress> {
+impl EthAddressZero of core::num::traits::Zero<EthAddress> {
     fn zero() -> EthAddress {
         0.try_into().unwrap()
     }
     #[inline(always)]
-    fn is_zero(self: EthAddress) -> bool {
-        self.address.is_zero()
+    fn is_zero(self: @EthAddress) -> bool {
+        core::num::traits::Zero::<felt252>::is_zero(self.address)
     }
     #[inline(always)]
-    fn is_non_zero(self: EthAddress) -> bool {
+    fn is_non_zero(self: @EthAddress) -> bool {
         !self.is_zero()
     }
 }
 
-impl EthAddressPrintImpl of PrintTrait<EthAddress> {
+pub(crate) impl EthAddressZeroable =
+    core::zeroable::zero_based::ZeroableImpl<EthAddress, EthAddressZero>;
+
+pub(crate) impl EthAddressPrintImpl of PrintTrait<EthAddress> {
     fn print(self: EthAddress) {
         self.address.print();
     }
 }
+
+impl DebugEthAddress = core::fmt::into_felt252_based::DebugImpl<EthAddress>;
diff --git a/corelib/src/starknet/eth_signature.cairo b/corelib/src/starknet/eth_signature.cairo
new file mode 100644
index 0000000..eaa91f3
--- /dev/null
+++ b/corelib/src/starknet/eth_signature.cairo
@@ -0,0 +1,59 @@
+use core::option::OptionTrait;
+use starknet::{
+    EthAddress,
+    secp256_trait::{
+        Secp256Trait, Secp256PointTrait, recover_public_key, is_signature_entry_valid, Signature
+    },
+    secp256k1::Secp256k1Point, SyscallResult, SyscallResultTrait
+};
+use core::keccak::keccak_u256s_be_inputs;
+
+/// Asserts that an Ethereum signature is valid w.r.t. a given Eth address
+/// Also verifies that r and s components of the signature are in the range (0, N),
+/// where N is the size of the curve.
+pub fn verify_eth_signature(msg_hash: u256, signature: Signature, eth_address: EthAddress) {
+    match is_eth_signature_valid(:msg_hash, :signature, :eth_address) {
+        Result::Ok(()) => {},
+        Result::Err(err) => core::panic_with_felt252(err),
+    }
+}
+
+/// Asserts that an Ethereum signature is valid w.r.t. a given Eth address
+/// Also verifies that r and s components of the signature are in the range (0, N),
+/// where N is the size of the curve.
+/// Returns a Result with an error string if the signature is invalid.
+pub fn is_eth_signature_valid(
+    msg_hash: u256, signature: Signature, eth_address: EthAddress
+) -> Result<(), felt252> {
+    if !is_signature_entry_valid::<Secp256k1Point>(signature.r) {
+        return Result::Err('Signature out of range');
+    }
+    if !is_signature_entry_valid::<Secp256k1Point>(signature.s) {
+        return Result::Err('Signature out of range');
+    }
+
+    let public_key_point = recover_public_key::<Secp256k1Point>(:msg_hash, :signature).unwrap();
+    let calculated_eth_address = public_key_point_to_eth_address(:public_key_point);
+    if eth_address != calculated_eth_address {
+        return Result::Err('Invalid signature');
+    }
+    Result::Ok(())
+}
+
+/// Converts a public key point to the corresponding Ethereum address.
+pub fn public_key_point_to_eth_address<
+    Secp256Point, +Drop<Secp256Point>, +Secp256Trait<Secp256Point>, +Secp256PointTrait<Secp256Point>
+>(
+    public_key_point: Secp256Point
+) -> EthAddress {
+    let (x, y) = public_key_point.get_coordinates().unwrap_syscall();
+
+    // Keccak output is little endian.
+    let point_hash_le = keccak_u256s_be_inputs(array![x, y].span());
+    let point_hash = u256 {
+        low: core::integer::u128_byte_reverse(point_hash_le.high),
+        high: core::integer::u128_byte_reverse(point_hash_le.low)
+    };
+
+    point_hash.into()
+}
diff --git a/corelib/src/starknet/event.cairo b/corelib/src/starknet/event.cairo
index 3689932..157ca97 100644
--- a/corelib/src/starknet/event.cairo
+++ b/corelib/src/starknet/event.cairo
@@ -1,8 +1,8 @@
-trait Event<T> {
+pub trait Event<T> {
     fn append_keys_and_data(self: @T, ref keys: Array<felt252>, ref data: Array<felt252>);
     fn deserialize(ref keys: Span<felt252>, ref data: Span<felt252>) -> Option<T>;
 }
 
-trait EventEmitter<T, TEvent> {
-    fn emit<S, impl IntoImp: traits::Into<S, TEvent>>(ref self: T, event: S);
+pub trait EventEmitter<T, TEvent> {
+    fn emit<S, +Into<S, TEvent>>(ref self: T, event: S);
 }
diff --git a/corelib/src/starknet/info.cairo b/corelib/src/starknet/info.cairo
index cd8a888..631db1b 100644
--- a/corelib/src/starknet/info.cairo
+++ b/corelib/src/starknet/info.cairo
@@ -2,70 +2,132 @@ use starknet::{
     SyscallResultTrait, SyscallResult, syscalls::get_execution_info_syscall,
     contract_address::ContractAddress
 };
-use box::BoxTrait;
+use core::box::BoxTrait;
 
-#[derive(Copy, Drop)]
-struct ExecutionInfo {
-    block_info: Box<BlockInfo>,
-    tx_info: Box<TxInfo>,
-    caller_address: ContractAddress,
-    contract_address: ContractAddress,
-    entry_point_selector: felt252,
+#[derive(Copy, Drop, Debug)]
+pub struct ExecutionInfo {
+    pub block_info: Box<BlockInfo>,
+    pub tx_info: Box<TxInfo>,
+    pub caller_address: ContractAddress,
+    pub contract_address: ContractAddress,
+    pub entry_point_selector: felt252,
 }
 
-#[derive(Copy, Drop, Serde)]
-struct BlockInfo {
-    block_number: u64,
-    block_timestamp: u64,
-    sequencer_address: ContractAddress,
+#[derive(Copy, Drop, Debug, Serde)]
+pub struct BlockInfo {
+    pub block_number: u64,
+    pub block_timestamp: u64,
+    pub sequencer_address: ContractAddress,
 }
 
-#[derive(Copy, Drop, Serde)]
-struct TxInfo {
+#[derive(Copy, Drop, Debug, Serde)]
+pub struct TxInfo {
     // The version of the transaction. It is fixed (currently, 1) in the OS, and should be
     // signed by the account contract.
     // This field allows invalidating old transactions, whenever the meaning of the other
     // transaction fields is changed (in the OS).
-    version: felt252,
+    pub version: felt252,
     // The account contract from which this transaction originates.
-    account_contract_address: ContractAddress,
+    pub account_contract_address: ContractAddress,
     // The max_fee field of the transaction.
-    max_fee: u128,
+    pub max_fee: u128,
     // The signature of the transaction.
-    signature: Span<felt252>,
+    pub signature: Span<felt252>,
     // The hash of the transaction.
-    transaction_hash: felt252,
+    pub transaction_hash: felt252,
     // The identifier of the chain.
     // This field can be used to prevent replay of testnet transactions on mainnet.
-    chain_id: felt252,
+    pub chain_id: felt252,
     // The transaction's nonce.
-    nonce: felt252,
+    pub nonce: felt252,
 }
 
-fn get_execution_info() -> Box<ExecutionInfo> {
-    get_execution_info_syscall().unwrap_syscall()
+pub fn get_execution_info() -> Box<v2::ExecutionInfo> {
+    starknet::syscalls::get_execution_info_v2_syscall().unwrap_syscall()
 }
 
-fn get_caller_address() -> ContractAddress {
+pub fn get_caller_address() -> ContractAddress {
     get_execution_info().unbox().caller_address
 }
 
-fn get_contract_address() -> ContractAddress {
+pub fn get_contract_address() -> ContractAddress {
     get_execution_info().unbox().contract_address
 }
 
-fn get_block_info() -> Box<BlockInfo> {
+pub fn get_block_info() -> Box<BlockInfo> {
     get_execution_info().unbox().block_info
 }
 
-fn get_tx_info() -> Box<TxInfo> {
+pub fn get_tx_info() -> Box<v2::TxInfo> {
     get_execution_info().unbox().tx_info
 }
 
-fn get_block_timestamp() -> u64 {
+pub fn get_block_timestamp() -> u64 {
     get_block_info().unbox().block_timestamp
 }
 
-fn get_block_number() -> u64 {
+pub fn get_block_number() -> u64 {
     get_block_info().unbox().block_number
 }
+
+/// The extended version of the `get_execution_info` syscall result.
+pub mod v2 {
+    use starknet::contract_address::ContractAddress;
+    use super::BlockInfo;
+
+    #[derive(Copy, Drop, Debug)]
+    pub struct ExecutionInfo {
+        pub block_info: Box<BlockInfo>,
+        pub tx_info: Box<TxInfo>,
+        pub caller_address: ContractAddress,
+        pub contract_address: ContractAddress,
+        pub entry_point_selector: felt252,
+    }
+
+    #[derive(Copy, Drop, Debug, Serde)]
+    pub struct TxInfo {
+        // The version of the transaction. It is fixed (currently, 1) in the OS, and should be
+        // signed by the account contract.
+        // This field allows invalidating old transactions, whenever the meaning of the other
+        // transaction fields is changed (in the OS).
+        pub version: felt252,
+        // The account contract from which this transaction originates.
+        pub account_contract_address: ContractAddress,
+        // The max_fee field of the transaction.
+        pub max_fee: u128,
+        // The signature of the transaction.
+        pub signature: Span<felt252>,
+        // The hash of the transaction.
+        pub transaction_hash: felt252,
+        // The identifier of the chain.
+        // This field can be used to prevent replay of testnet transactions on mainnet.
+        pub chain_id: felt252,
+        // The transaction's nonce.
+        pub nonce: felt252,
+        // A span of ResourceBounds structs.
+        pub resource_bounds: Span<ResourceBounds>,
+        // The tip.
+        pub tip: u128,
+        // If specified, the paymaster should pay for the execution of the tx.
+        // The data includes the address of the paymaster sponsoring the transaction, followed by
+        // extra data to send to the paymaster.
+        pub paymaster_data: Span<felt252>,
+        // The data availability mode for the nonce.
+        pub nonce_data_availability_mode: u32,
+        // The data availability mode for the account balance from which fee will be taken.
+        pub fee_data_availability_mode: u32,
+        // If nonempty, will contain the required data for deploying and initializing an account
+        // contract: its class hash, address salt and constructor calldata.
+        pub account_deployment_data: Span<felt252>,
+    }
+
+    #[derive(Copy, Drop, Debug, Serde)]
+    pub struct ResourceBounds {
+        // The name of the resource.
+        pub resource: felt252,
+        // The maximum amount of the resource allowed for usage during the execution.
+        pub max_amount: u64,
+        // The maximum price the user is willing to pay for the resource unit.
+        pub max_price_per_unit: u128,
+    }
+}
diff --git a/corelib/src/starknet/secp256_trait.cairo b/corelib/src/starknet/secp256_trait.cairo
index 72db7e7..1fda813 100644
--- a/corelib/src/starknet/secp256_trait.cairo
+++ b/corelib/src/starknet/secp256_trait.cairo
@@ -1,21 +1,20 @@
-use array::ArrayTrait;
-use keccak::keccak_u256s_be_inputs;
-use math::{u256_mul_mod_n, inv_mod};
-use option::OptionTrait;
+use core::array::ArrayTrait;
+use core::math::{u256_mul_mod_n, u256_inv_mod};
+use core::option::OptionTrait;
 use starknet::{eth_address::U256IntoEthAddress, EthAddress, SyscallResult, SyscallResultTrait};
-use traits::{Into, TryInto};
-use integer::U256TryIntoNonZero;
+use core::traits::{Into, TryInto};
+use core::integer::U256TryIntoNonZero;
 
 /// Secp256{k/r}1 ECDSA signature.
-#[derive(Copy, Drop, PartialEq, Serde, starknet::Store)]
-struct Signature {
-    r: u256,
-    s: u256,
+#[derive(Copy, Drop, Debug, PartialEq, Serde, starknet::Store, Hash)]
+pub struct Signature {
+    pub r: u256,
+    pub s: u256,
     // The parity of the y coordinate of the ec point whose x coordinate is `r`.
     // `y_parity` == true means that the y coordinate is odd.
     // Some places use non boolean v instead of y_parity.
     // In that case, `signature_from_vrs` should be used.
-    y_parity: bool,
+    pub y_parity: bool,
 }
 
 
@@ -23,11 +22,11 @@ struct Signature {
 /// `v` is the sum of an odd number and the parity of the y coordinate of the ec point whose x
 /// coordinate is `r`.
 /// See https://eips.ethereum.org/EIPS/eip-155 for more details.
-fn signature_from_vrs(v: u32, r: u256, s: u256) -> Signature {
+pub fn signature_from_vrs(v: u32, r: u256, s: u256) -> Signature {
     Signature { r, s, y_parity: v % 2 == 0 }
 }
 
-trait Secp256Trait<Secp256Point> {
+pub trait Secp256Trait<Secp256Point> {
     fn get_curve_size() -> u256;
     fn get_generator_point() -> Secp256Point;
 
@@ -37,20 +36,55 @@ trait Secp256Trait<Secp256Point> {
     ) -> SyscallResult<Option<Secp256Point>>;
 }
 
-trait Secp256PointTrait<Secp256Point> {
+pub trait Secp256PointTrait<Secp256Point> {
     fn get_coordinates(self: Secp256Point) -> SyscallResult<(u256, u256)>;
     fn add(self: Secp256Point, other: Secp256Point) -> SyscallResult<Secp256Point>;
     fn mul(self: Secp256Point, scalar: u256) -> SyscallResult<Secp256Point>;
 }
 
+/// Checks whether `value` is in the range [1, N), where N is the size of the curve.
+pub fn is_signature_entry_valid<
+    Secp256Point, +Drop<Secp256Point>, impl Secp256Impl: Secp256Trait<Secp256Point>
+>(
+    value: u256
+) -> bool {
+    value != 0_u256 && value < Secp256Impl::get_curve_size()
+}
+
+pub fn is_valid_signature<
+    Secp256Point,
+    +Drop<Secp256Point>,
+    impl Secp256Impl: Secp256Trait<Secp256Point>,
+    +Secp256PointTrait<Secp256Point>
+>(
+    msg_hash: u256, r: u256, s: u256, public_key: Secp256Point
+) -> bool {
+    if !is_signature_entry_valid::<Secp256Point>(r)
+        || !is_signature_entry_valid::<Secp256Point>(s) {
+        return false;
+    }
+
+    let n_nz = Secp256Impl::get_curve_size().try_into().unwrap();
+    let s_inv = u256_inv_mod(s.try_into().unwrap(), n_nz).unwrap().into();
+    let u1 = u256_mul_mod_n(msg_hash, s_inv, n_nz);
+    let u2 = u256_mul_mod_n(r, s_inv, n_nz);
+
+    let generator_point = Secp256Impl::get_generator_point();
+    let point1 = generator_point.mul(u1).unwrap_syscall();
+    let point2 = public_key.mul(u2).unwrap_syscall();
+    let sum = point1.add(point2).unwrap_syscall();
+
+    let (x, _y) = sum.get_coordinates().unwrap_syscall();
+    x == r
+}
 
 /// Receives a signature and the signed message hash.
 /// Returns the public key associated with the signer, represented as a point on the curve.
-fn recover_public_key<
+pub fn recover_public_key<
     Secp256Point,
-    impl Secp256PointDrop: Drop<Secp256Point>,
+    +Drop<Secp256Point>,
     impl Secp256Impl: Secp256Trait<Secp256Point>,
-    impl Secp256PointImpl: Secp256PointTrait<Secp256Point>
+    +Secp256PointTrait<Secp256Point>
 >(
     msg_hash: u256, signature: Signature
 ) -> Option<Secp256Point> {
@@ -64,7 +98,7 @@ fn recover_public_key<
     // where the divisions by `r` are modulo `N` (the size of the curve).
 
     let n_nz = Secp256Impl::get_curve_size().try_into().unwrap();
-    let r_inv = inv_mod(r.try_into().unwrap(), n_nz).unwrap();
+    let r_inv = u256_inv_mod(r.try_into().unwrap(), n_nz).unwrap().into();
 
     let u1 = u256_mul_mod_n(msg_hash, r_inv, n_nz);
     let minus_u1 = secp256_ec_negate_scalar::<Secp256Point>(u1);
@@ -79,88 +113,9 @@ fn recover_public_key<
 
 /// Computes the negation of a scalar modulo N (the size of the curve).
 fn secp256_ec_negate_scalar<
-    Secp256Point,
-    impl Secp256PointDrop: Drop<Secp256Point>,
-    impl Secp256Impl: Secp256Trait<Secp256Point>
+    Secp256Point, +Drop<Secp256Point>, impl Secp256Impl: Secp256Trait<Secp256Point>
 >(
     c: u256
 ) -> u256 {
     Secp256Impl::get_curve_size() - c
 }
-
-
-/// Checks a Secp256 ECDSA signature.
-/// Also verifies that r and s components of the signature are in the range (0, N),
-/// where N is the size of the curve.
-/// Returns a Result with an error string if the signature is invalid.
-fn is_eth_signature_valid<
-    Secp256Point,
-    impl Secp256PointDrop: Drop<Secp256Point>,
-    impl Secp256Impl: Secp256Trait<Secp256Point>,
-    impl Secp256PointImpl: Secp256PointTrait<Secp256Point>
->(
-    msg_hash: u256, signature: Signature, eth_address: EthAddress
-) -> Result<(), felt252> {
-    if !is_signature_entry_valid::<Secp256Point>(signature.r) {
-        return Result::Err('Signature out of range');
-    }
-    if !is_signature_entry_valid::<Secp256Point>(signature.s) {
-        return Result::Err('Signature out of range');
-    }
-
-    let public_key_point = recover_public_key::<Secp256Point>(:msg_hash, :signature).unwrap();
-    let calculated_eth_address = public_key_point_to_eth_address(:public_key_point);
-    if eth_address != calculated_eth_address {
-        return Result::Err('Invalid signature');
-    }
-    Result::Ok(())
-}
-
-/// Asserts that a Secp256 ECDSA signature is valid.
-/// Also verifies that r and s components of the signature are in the range (0, N),
-/// where N is the size of the curve.
-fn verify_eth_signature<
-    Secp256Point,
-    impl Secp256PointDrop: Drop<Secp256Point>,
-    impl Secp256Impl: Secp256Trait<Secp256Point>,
-    impl Secp256PointImpl: Secp256PointTrait<Secp256Point>
->(
-    msg_hash: u256, signature: Signature, eth_address: EthAddress
-) {
-    match is_eth_signature_valid::<Secp256Point>(:msg_hash, :signature, :eth_address) {
-        Result::Ok(()) => {},
-        Result::Err(err) => panic_with_felt252(err),
-    }
-}
-
-/// Checks whether `value` is in the range [1, N), where N is the size of the curve.
-fn is_signature_entry_valid<
-    Secp256Point,
-    impl Secp256PointDrop: Drop<Secp256Point>,
-    impl Secp256Impl: Secp256Trait<Secp256Point>
->(
-    value: u256
-) -> bool {
-    value != 0_u256 && value < Secp256Impl::get_curve_size()
-}
-
-/// Converts a public key point to the corresponding Ethereum address.
-fn public_key_point_to_eth_address<
-    Secp256Point,
-    impl Secp256PointDrop: Drop<Secp256Point>,
-    impl Secp256Impl: Secp256Trait<Secp256Point>,
-    impl Secp256PointImpl: Secp256PointTrait<Secp256Point>
->(
-    public_key_point: Secp256Point
-) -> EthAddress {
-    let (x, y) = public_key_point.get_coordinates().unwrap_syscall();
-
-    // Keccak output is little endian.
-    let point_hash_le = keccak_u256s_be_inputs(array![x, y].span());
-    let point_hash = u256 {
-        low: integer::u128_byte_reverse(point_hash_le.high),
-        high: integer::u128_byte_reverse(point_hash_le.low)
-    };
-
-    point_hash.into()
-}
diff --git a/corelib/src/starknet/secp256k1.cairo b/corelib/src/starknet/secp256k1.cairo
index 7030844..a3a4f24 100644
--- a/corelib/src/starknet/secp256k1.cairo
+++ b/corelib/src/starknet/secp256k1.cairo
@@ -1,15 +1,18 @@
 //! This module contains functions and constructs related to elliptic curve operations on the
 //! secp256k1 curve.
 
-use option::OptionTrait;
+use core::option::OptionTrait;
 use starknet::{
-    EthAddress, secp256_trait::{Secp256Trait, Secp256PointTrait}, SyscallResult, SyscallResultTrait
+    secp256_trait::{
+        Secp256Trait, Secp256PointTrait, recover_public_key, is_signature_entry_valid, Signature
+    },
+    SyscallResult, SyscallResultTrait
 };
 
 #[derive(Copy, Drop)]
-extern type Secp256k1Point;
+pub extern type Secp256k1Point;
 
-impl Secp256k1Impl of Secp256Trait<Secp256k1Point> {
+pub(crate) impl Secp256k1Impl of Secp256Trait<Secp256k1Point> {
     // TODO(yuval): change to constant once u256 constants are supported.
     fn get_curve_size() -> u256 {
         0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141
@@ -34,7 +37,7 @@ impl Secp256k1Impl of Secp256Trait<Secp256k1Point> {
     }
 }
 
-impl Secp256k1PointImpl of Secp256PointTrait<Secp256k1Point> {
+pub(crate) impl Secp256k1PointImpl of Secp256PointTrait<Secp256k1Point> {
     fn get_coordinates(self: Secp256k1Point) -> SyscallResult<(u256, u256)> {
         secp256k1_get_xy_syscall(self)
     }
diff --git a/corelib/src/starknet/secp256r1.cairo b/corelib/src/starknet/secp256r1.cairo
index 65fdfcc..362fe79 100644
--- a/corelib/src/starknet/secp256r1.cairo
+++ b/corelib/src/starknet/secp256r1.cairo
@@ -1,15 +1,15 @@
 //! This module contains functions and constructs related to elliptic curve operations on the
 //! secp256r1 curve.
 
-use option::OptionTrait;
+use core::option::OptionTrait;
 use starknet::{
     EthAddress, secp256_trait::{Secp256Trait, Secp256PointTrait}, SyscallResult, SyscallResultTrait
 };
 
 #[derive(Copy, Drop)]
-extern type Secp256r1Point;
+pub extern type Secp256r1Point;
 
-impl Secp256r1Impl of Secp256Trait<Secp256r1Point> {
+pub(crate) impl Secp256r1Impl of Secp256Trait<Secp256r1Point> {
     // TODO(yuval): change to constant once u256 constants are supported.
     fn get_curve_size() -> u256 {
         0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551
@@ -34,7 +34,7 @@ impl Secp256r1Impl of Secp256Trait<Secp256r1Point> {
     }
 }
 
-impl Secp256r1PointImpl of Secp256PointTrait<Secp256r1Point> {
+pub(crate) impl Secp256r1PointImpl of Secp256PointTrait<Secp256r1Point> {
     fn get_coordinates(self: Secp256r1Point) -> SyscallResult<(u256, u256)> {
         secp256r1_get_xy_syscall(self)
     }
diff --git a/corelib/src/starknet/storage.cairo b/corelib/src/starknet/storage.cairo
new file mode 100644
index 0000000..ac2dabc
--- /dev/null
+++ b/corelib/src/starknet/storage.cairo
@@ -0,0 +1,71 @@
+/// Trait for getting the address of any contract/component storage member.
+pub trait StorageMemberAddressTrait<TMemberState, TValue> {
+    fn address(self: @TMemberState) -> starknet::StorageBaseAddress nopanic;
+}
+
+/// Trait for accessing any contract/component storage member.
+pub trait StorageMemberAccessTrait<TMemberState, TValue> {
+    fn read(self: @TMemberState) -> TValue;
+    fn write(ref self: TMemberState, value: TValue);
+}
+
+/// Implementation of StorageMemberAccessTrait for types that implement StorageMemberAddressTrait.
+pub impl StorageMemberAccessImpl<
+    TMemberState,
+    TValue,
+    +StorageMemberAddressTrait<TMemberState, TValue>,
+    +starknet::Store<TValue>,
+    +Drop<TMemberState>,
+> of StorageMemberAccessTrait<TMemberState, TValue> {
+    fn read(self: @TMemberState) -> TValue {
+        // Only address_domain 0 is currently supported.
+        let address_domain = 0_u32;
+        starknet::SyscallResultTrait::unwrap_syscall(
+            starknet::Store::<TValue>::read(address_domain, self.address())
+        )
+    }
+    fn write(ref self: TMemberState, value: TValue) {
+        // Only address_domain 0 is currently supported.
+        let address_domain = 0_u32;
+        let write_result = starknet::Store::<TValue>::write(address_domain, self.address(), value);
+        starknet::SyscallResultTrait::unwrap_syscall(write_result)
+    }
+}
+
+/// Trait for getting the address of any contract/component mapping storage member.
+pub trait StorageMapMemberAddressTrait<TMemberState, TKey, TValue> {
+    fn address(self: @TMemberState, key: TKey) -> starknet::StorageBaseAddress;
+}
+
+/// Trait for accessing any contract/component storage member.
+pub trait StorageMapMemberAccessTrait<TMemberState, TKey, TValue> {
+    fn read(self: @TMemberState, key: TKey) -> TValue;
+    fn write(ref self: TMemberState, key: TKey, value: TValue);
+}
+
+/// Implementation of StorageMapMemberAccessTrait for types that implement
+/// StorageMapMemberAddressTrait.
+pub impl StorageMapMemberAccessImpl<
+    TMemberState,
+    TKey,
+    TValue,
+    +StorageMapMemberAddressTrait<TMemberState, TKey, TValue>,
+    +starknet::Store<TValue>,
+    +Drop<TMemberState>,
+    +PanicDestruct<TValue>,
+> of StorageMapMemberAccessTrait<TMemberState, TKey, TValue> {
+    fn read(self: @TMemberState, key: TKey) -> TValue {
+        // Only address_domain 0 is currently supported.
+        let address_domain = 0_u32;
+        starknet::SyscallResultTrait::unwrap_syscall(
+            starknet::Store::<TValue>::read(address_domain, self.address(key))
+        )
+    }
+    fn write(ref self: TMemberState, key: TKey, value: TValue) {
+        // Only address_domain 0 is currently supported.
+        let address_domain = 0_u32;
+        starknet::SyscallResultTrait::unwrap_syscall(
+            starknet::Store::<TValue>::write(address_domain, self.address(key), value)
+        )
+    }
+}
diff --git a/corelib/src/starknet/storage_access.cairo b/corelib/src/starknet/storage_access.cairo
index 8cbae63..ad88367 100644
--- a/corelib/src/starknet/storage_access.cairo
+++ b/corelib/src/starknet/storage_access.cairo
@@ -1,33 +1,35 @@
 use core::array::ArrayTrait;
-use traits::{Into, TryInto};
-use option::OptionTrait;
+use core::traits::{Into, TryInto};
+use core::option::OptionTrait;
+use core::byte_array::ByteArrayTrait;
+use core::bytes_31::BYTES_IN_BYTES31;
 use starknet::{
     SyscallResult, syscalls::{storage_read_syscall, storage_write_syscall},
     contract_address::{ContractAddress, Felt252TryIntoContractAddress, ContractAddressIntoFelt252},
     class_hash::{ClassHash, Felt252TryIntoClassHash, ClassHashIntoFelt252}
 };
-use serde::Serde;
+use core::serde::Serde;
 
 #[derive(Copy, Drop)]
-extern type StorageAddress;
+pub extern type StorageAddress;
 
 #[derive(Copy, Drop)]
-extern type StorageBaseAddress;
+pub extern type StorageBaseAddress;
 
 // Storage.
-extern fn storage_base_address_const<const address: felt252>() -> StorageBaseAddress nopanic;
-extern fn storage_base_address_from_felt252(
+pub extern fn storage_base_address_const<const address: felt252>() -> StorageBaseAddress nopanic;
+pub extern fn storage_base_address_from_felt252(
     addr: felt252
 ) -> StorageBaseAddress implicits(RangeCheck) nopanic;
 
-extern fn storage_address_to_felt252(address: StorageAddress) -> felt252 nopanic;
-extern fn storage_address_from_base_and_offset(
+pub(crate) extern fn storage_address_to_felt252(address: StorageAddress) -> felt252 nopanic;
+pub extern fn storage_address_from_base_and_offset(
     base: StorageBaseAddress, offset: u8
 ) -> StorageAddress nopanic;
 
-extern fn storage_address_from_base(base: StorageBaseAddress) -> StorageAddress nopanic;
+pub extern fn storage_address_from_base(base: StorageBaseAddress) -> StorageAddress nopanic;
 
-extern fn storage_address_try_from_felt252(
+pub(crate) extern fn storage_address_try_from_felt252(
     address: felt252
 ) -> Option<StorageAddress> implicits(RangeCheck) nopanic;
 
@@ -42,31 +44,49 @@ impl StorageAddressIntoFelt252 of Into<StorageAddress, felt252> {
     }
 }
 
-impl StorageAddressSerde of serde::Serde<StorageAddress> {
+impl StorageAddressSerde of Serde<StorageAddress> {
     fn serialize(self: @StorageAddress, ref output: Array<felt252>) {
         storage_address_to_felt252(*self).serialize(ref output);
     }
     fn deserialize(ref serialized: Span<felt252>) -> Option<StorageAddress> {
         Option::Some(
-            storage_address_try_from_felt252(serde::Serde::<felt252>::deserialize(ref serialized)?)?
+            storage_address_try_from_felt252(Serde::<felt252>::deserialize(ref serialized)?)?
         )
     }
 }
 
-trait Store<T> {
+impl DebugStorageAddress = core::fmt::into_felt252_based::DebugImpl<StorageAddress>;
+impl DebugStorageBaseAddress of core::fmt::Debug<StorageBaseAddress> {
+    fn fmt(self: @StorageBaseAddress, ref f: core::fmt::Formatter) -> Result<(), core::fmt::Error> {
+        DebugStorageAddress::fmt(@storage_address_from_base(*self), ref f)
+    }
+}
+
+/// Trait for types that can be used as a value in Starknet storage variables.
+pub trait Store<T> {
+    /// Reads a value from storage from domain `address_domain` and base address `base`.
     fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<T>;
+    /// Writes a value to storage to domain `address_domain` and base address `base`.
     fn write(address_domain: u32, base: StorageBaseAddress, value: T) -> SyscallResult<()>;
+    /// Reads a value from storage from domain `address_domain` and base address `base` at offset
+    /// `offset`.
     fn read_at_offset(
         address_domain: u32, base: StorageBaseAddress, offset: u8
     ) -> SyscallResult<T>;
+    /// Writes a value to storage to domain `address_domain` and base address `base` at offset
+    /// `offset`.
     fn write_at_offset(
         address_domain: u32, base: StorageBaseAddress, offset: u8, value: T
     ) -> SyscallResult<()>;
     fn size() -> u8;
 }
 
-trait StorePacking<T, PackedT> {
+/// Trait for easier implementation of `Store` used for packing and unpacking values into values
+/// that already implement `Store`, and having `Store` implemented using this conversion.
+pub trait StorePacking<T, PackedT> {
+    /// Packs a value of type `T` into a value of type `PackedT`.
     fn pack(value: T) -> PackedT;
+    /// Unpacks a value of type `PackedT` into a value of type `T`.
     fn unpack(value: PackedT) -> T;
 }
 
@@ -128,295 +148,163 @@ impl StoreFelt252 of Store<felt252> {
     }
 }
 
-impl StoreBool of Store<bool> {
-    fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<bool> {
-        Result::Ok(Store::<felt252>::read(address_domain, base)? != 0)
-    }
-    #[inline(always)]
-    fn write(address_domain: u32, base: StorageBaseAddress, value: bool) -> SyscallResult<()> {
-        Store::<felt252>::write(address_domain, base, if value {
-            1
-        } else {
-            0
-        })
+impl StorePackingBool of StorePacking<bool, felt252> {
+    fn pack(value: bool) -> felt252 {
+        value.into()
     }
-    #[inline(always)]
-    fn read_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8
-    ) -> SyscallResult<bool> {
-        Result::Ok(Store::<felt252>::read_at_offset(address_domain, base, offset)? != 0)
-    }
-    #[inline(always)]
-    fn write_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8, value: bool
-    ) -> SyscallResult<()> {
-        Store::<felt252>::write_at_offset(address_domain, base, offset, if value {
-            1
-        } else {
-            0
-        })
-    }
-    #[inline(always)]
-    fn size() -> u8 {
-        1_u8
+    #[inline]
+    fn unpack(value: felt252) -> bool {
+        value != 0
     }
 }
 
-impl StoreU8 of Store<u8> {
-    fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<u8> {
-        Result::Ok(
-            Store::<felt252>::read(address_domain, base)?.try_into().expect('StoreU8 - non u8')
-        )
-    }
-    #[inline(always)]
-    fn write(address_domain: u32, base: StorageBaseAddress, value: u8) -> SyscallResult<()> {
-        Store::<felt252>::write(address_domain, base, value.into())
-    }
-    #[inline(always)]
-    fn read_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8
-    ) -> SyscallResult<u8> {
-        Result::Ok(
-            Store::<felt252>::read_at_offset(address_domain, base, offset)?
-                .try_into()
-                .expect('StoreU8 - non u8')
-        )
-    }
-    #[inline(always)]
-    fn write_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8, value: u8
-    ) -> SyscallResult<()> {
-        Store::<felt252>::write_at_offset(address_domain, base, offset, value.into())
+impl StorePackingU8 of StorePacking<u8, felt252> {
+    fn pack(value: u8) -> felt252 {
+        value.into()
     }
-    #[inline(always)]
-    fn size() -> u8 {
-        1_u8
+    #[inline]
+    fn unpack(value: felt252) -> u8 {
+        value.try_into().expect('StoreU8 - non u8')
     }
 }
 
-impl StoreU16 of Store<u16> {
-    fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<u16> {
-        Result::Ok(
-            Store::<felt252>::read(address_domain, base)?.try_into().expect('StoreU16 - non u16')
-        )
+impl StorePackingI8 of StorePacking<i8, felt252> {
+    fn pack(value: i8) -> felt252 {
+        value.into()
     }
-    #[inline(always)]
-    fn write(address_domain: u32, base: StorageBaseAddress, value: u16) -> SyscallResult<()> {
-        Store::<felt252>::write(address_domain, base, value.into())
+    #[inline]
+    fn unpack(value: felt252) -> i8 {
+        value.try_into().expect('StoreI8 - non i8')
     }
-    #[inline(always)]
-    fn read_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8
-    ) -> SyscallResult<u16> {
-        Result::Ok(
-            Store::<felt252>::read_at_offset(address_domain, base, offset)?
-                .try_into()
-                .expect('StoreU16 - non u16')
-        )
-    }
-    #[inline(always)]
-    fn write_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8, value: u16
-    ) -> SyscallResult<()> {
-        Store::<felt252>::write_at_offset(address_domain, base, offset, value.into())
+}
+
+impl StorePackingU16 of StorePacking<u16, felt252> {
+    fn pack(value: u16) -> felt252 {
+        value.into()
     }
-    #[inline(always)]
-    fn size() -> u8 {
-        1_u8
+    #[inline]
+    fn unpack(value: felt252) -> u16 {
+        value.try_into().expect('StoreU16 - non u16')
     }
 }
 
-impl StoreU32 of Store<u32> {
-    fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<u32> {
-        Result::Ok(
-            Store::<felt252>::read(address_domain, base)?.try_into().expect('StoreU32 - non u32')
-        )
+impl StorePackingI16 of StorePacking<i16, felt252> {
+    fn pack(value: i16) -> felt252 {
+        value.into()
     }
-    #[inline(always)]
-    fn write(address_domain: u32, base: StorageBaseAddress, value: u32) -> SyscallResult<()> {
-        Store::<felt252>::write(address_domain, base, value.into())
-    }
-    #[inline(always)]
-    fn read_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8
-    ) -> SyscallResult<u32> {
-        Result::Ok(
-            Store::<felt252>::read_at_offset(address_domain, base, offset)?
-                .try_into()
-                .expect('StoreU32 - non u32')
-        )
+    #[inline]
+    fn unpack(value: felt252) -> i16 {
+        value.try_into().expect('StoreI16 - non i16')
     }
-    #[inline(always)]
-    fn write_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8, value: u32
-    ) -> SyscallResult<()> {
-        Store::<felt252>::write_at_offset(address_domain, base, offset, value.into())
+}
+
+impl StorePackingU32 of StorePacking<u32, felt252> {
+    fn pack(value: u32) -> felt252 {
+        value.into()
     }
-    #[inline(always)]
-    fn size() -> u8 {
-        1_u8
+    #[inline]
+    fn unpack(value: felt252) -> u32 {
+        value.try_into().expect('StoreU32 - non u32')
     }
 }
 
-impl StoreU64 of Store<u64> {
-    fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<u64> {
-        Result::Ok(
-            Store::<felt252>::read(address_domain, base)?.try_into().expect('StoreU64 - non u64')
-        )
+impl StorePackingI32 of StorePacking<i32, felt252> {
+    fn pack(value: i32) -> felt252 {
+        value.into()
     }
-    #[inline(always)]
-    fn write(address_domain: u32, base: StorageBaseAddress, value: u64) -> SyscallResult<()> {
-        Store::<felt252>::write(address_domain, base, value.into())
-    }
-    #[inline(always)]
-    fn read_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8
-    ) -> SyscallResult<u64> {
-        Result::Ok(
-            Store::<felt252>::read_at_offset(address_domain, base, offset)?
-                .try_into()
-                .expect('StoreU64 - non u64')
-        )
+    #[inline]
+    fn unpack(value: felt252) -> i32 {
+        value.try_into().expect('StoreI32 - non i32')
     }
-    #[inline(always)]
-    fn write_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8, value: u64
-    ) -> SyscallResult<()> {
-        Store::<felt252>::write_at_offset(address_domain, base, offset, value.into())
+}
+
+impl StorePackingU64 of StorePacking<u64, felt252> {
+    fn pack(value: u64) -> felt252 {
+        value.into()
     }
-    #[inline(always)]
-    fn size() -> u8 {
-        1_u8
+    #[inline]
+    fn unpack(value: felt252) -> u64 {
+        value.try_into().expect('StoreU64 - non u64')
     }
 }
 
-impl StoreU128 of Store<u128> {
-    fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<u128> {
-        Result::Ok(
-            Store::<felt252>::read(address_domain, base)?.try_into().expect('StoreU128 - non u128')
-        )
+impl StorePackingI64 of StorePacking<i64, felt252> {
+    fn pack(value: i64) -> felt252 {
+        value.into()
     }
-    #[inline(always)]
-    fn write(address_domain: u32, base: StorageBaseAddress, value: u128) -> SyscallResult<()> {
-        Store::<felt252>::write(address_domain, base, value.into())
+    #[inline]
+    fn unpack(value: felt252) -> i64 {
+        value.try_into().expect('StoreI64 - non i64')
     }
-    #[inline(always)]
-    fn read_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8
-    ) -> SyscallResult<u128> {
-        Result::Ok(
-            Store::<felt252>::read_at_offset(address_domain, base, offset)?
-                .try_into()
-                .expect('StoreU128 - non u128')
-        )
-    }
-    #[inline(always)]
-    fn write_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8, value: u128
-    ) -> SyscallResult<()> {
-        Store::<felt252>::write_at_offset(address_domain, base, offset, value.into())
+}
+
+impl StorePackingU128 of StorePacking<u128, felt252> {
+    fn pack(value: u128) -> felt252 {
+        value.into()
     }
-    #[inline(always)]
-    fn size() -> u8 {
-        1_u8
+    #[inline]
+    fn unpack(value: felt252) -> u128 {
+        value.try_into().expect('StoreU128 - non u128')
     }
 }
 
-impl StoreStorageAddress of Store<StorageAddress> {
-    fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<StorageAddress> {
-        Result::Ok(
-            Store::<felt252>::read(address_domain, base)?.try_into().expect('Non StorageAddress')
-        )
-    }
-    #[inline(always)]
-    fn write(
-        address_domain: u32, base: StorageBaseAddress, value: StorageAddress
-    ) -> SyscallResult<()> {
-        Store::<felt252>::write(address_domain, base, value.into())
+impl StorePackingI128 of StorePacking<i128, felt252> {
+    fn pack(value: i128) -> felt252 {
+        value.into()
     }
-    #[inline(always)]
-    fn read_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8
-    ) -> SyscallResult<StorageAddress> {
-        Result::Ok(
-            Store::<felt252>::read_at_offset(address_domain, base, offset)?
-                .try_into()
-                .expect('Non StorageAddress')
-        )
+    #[inline]
+    fn unpack(value: felt252) -> i128 {
+        value.try_into().expect('StoreI128 - non i128')
     }
-    #[inline(always)]
-    fn write_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8, value: StorageAddress
-    ) -> SyscallResult<()> {
-        Store::<felt252>::write_at_offset(address_domain, base, offset, value.into())
+}
+
+impl StorePackingBytes31 of StorePacking<bytes31, felt252> {
+    fn pack(value: bytes31) -> felt252 {
+        value.into()
     }
-    #[inline(always)]
-    fn size() -> u8 {
-        1_u8
+    #[inline]
+    fn unpack(value: felt252) -> bytes31 {
+        value.try_into().expect('StoreBytes31 - non bytes31')
     }
 }
 
-impl StoreContractAddress of Store<ContractAddress> {
-    fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<ContractAddress> {
-        Result::Ok(
-            Store::<felt252>::read(address_domain, base)?.try_into().expect('Non ContractAddress')
-        )
-    }
-    #[inline(always)]
-    fn write(
-        address_domain: u32, base: StorageBaseAddress, value: ContractAddress
-    ) -> SyscallResult<()> {
-        Store::<felt252>::write(address_domain, base, value.into())
+impl StorePackingNonZero<T, +TryInto<T, NonZero<T>>> of StorePacking<NonZero<T>, T> {
+    fn pack(value: NonZero<T>) -> T {
+        value.into()
     }
-    #[inline(always)]
-    fn read_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8
-    ) -> SyscallResult<ContractAddress> {
-        Result::Ok(
-            Store::<felt252>::read_at_offset(address_domain, base, offset)?
-                .try_into()
-                .expect('Non ContractAddress')
-        )
+    #[inline]
+    fn unpack(value: T) -> NonZero<T> {
+        value.try_into().expect('StoreNonZero - zero value')
     }
-    #[inline(always)]
-    fn write_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8, value: ContractAddress
-    ) -> SyscallResult<()> {
-        Store::<felt252>::write_at_offset(address_domain, base, offset, value.into())
+}
+
+impl StorePackingStorageAddress of StorePacking<StorageAddress, felt252> {
+    fn pack(value: StorageAddress) -> felt252 {
+        value.into()
     }
-    #[inline(always)]
-    fn size() -> u8 {
-        1_u8
+    #[inline]
+    fn unpack(value: felt252) -> StorageAddress {
+        value.try_into().expect('Non StorageAddress')
     }
 }
 
-impl StoreClassHash of Store<ClassHash> {
-    fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<ClassHash> {
-        Result::Ok(Store::<felt252>::read(address_domain, base)?.try_into().expect('Non ClassHash'))
+impl StorePackingContractAddress of StorePacking<ContractAddress, felt252> {
+    fn pack(value: ContractAddress) -> felt252 {
+        value.into()
     }
-    #[inline(always)]
-    fn write(address_domain: u32, base: StorageBaseAddress, value: ClassHash) -> SyscallResult<()> {
-        Store::<felt252>::write(address_domain, base, value.into())
-    }
-    #[inline(always)]
-    fn read_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8
-    ) -> SyscallResult<ClassHash> {
-        Result::Ok(
-            Store::<felt252>::read_at_offset(address_domain, base, offset)?
-                .try_into()
-                .expect('Non ClassHash')
-        )
+    #[inline]
+    fn unpack(value: felt252) -> ContractAddress {
+        value.try_into().expect('Non ContractAddress')
     }
-    #[inline(always)]
-    fn write_at_offset(
-        address_domain: u32, base: StorageBaseAddress, offset: u8, value: ClassHash
-    ) -> SyscallResult<()> {
-        Store::<felt252>::write_at_offset(address_domain, base, offset, value.into())
+}
+
+impl StorePackingClassHash of StorePacking<ClassHash, felt252> {
+    fn pack(value: ClassHash) -> felt252 {
+        value.into()
     }
-    #[inline(always)]
-    fn size() -> u8 {
-        1_u8
+    #[inline]
+    fn unpack(value: felt252) -> ClassHash {
+        value.try_into().expect('Non ClassHash')
     }
 }
 
@@ -447,7 +335,7 @@ impl TupleSize0Store of Store<()> {
     }
 }
 
-impl TupleSize1Store<E0, impl E0Store: Store<E0>, impl E0Drop: Drop<E0>> of Store<(E0,)> {
+impl TupleSize1Store<E0, impl E0Store: Store<E0>, +Drop<E0>> of Store<(E0,)> {
     #[inline(always)]
     fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<(E0,)> {
         Result::Ok((E0Store::read(address_domain, base)?,))
@@ -477,12 +365,7 @@ impl TupleSize1Store<E0, impl E0Store: Store<E0>, impl E0Drop: Drop<E0>> of Stor
 }
 
 impl TupleSize2Store<
-    E0,
-    E1,
-    impl E0Store: Store<E0>,
-    impl E0Drop: Drop<E0>,
-    impl E1Store: Store<E1>,
-    impl E0Drop: Drop<E1>
+    E0, E1, impl E0Store: Store<E0>, +Drop<E0>, impl E1Store: Store<E1>, +Drop<E1>
 > of Store<(E0, E1)> {
     #[inline(always)]
     fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<(E0, E1)> {
@@ -525,11 +408,11 @@ impl TupleSize3Store<
     E1,
     E2,
     impl E0Store: Store<E0>,
-    impl E0Drop: Drop<E0>,
+    +Drop<E0>,
     impl E1Store: Store<E1>,
-    impl E1Drop: Drop<E1>,
+    +Drop<E1>,
     impl E2Store: Store<E2>,
-    impl E2Drop: Drop<E2>
+    +Drop<E2>
 > of Store<(E0, E1, E2)> {
     #[inline(always)]
     fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<(E0, E1, E2)> {
@@ -585,13 +468,13 @@ impl TupleSize4Store<
     E2,
     E3,
     impl E0Store: Store<E0>,
-    impl E0Drop: Drop<E0>,
+    +Drop<E0>,
     impl E1Store: Store<E1>,
-    impl E1Drop: Drop<E1>,
+    +Drop<E1>,
     impl E2Store: Store<E2>,
-    impl E2Drop: Drop<E2>,
+    +Drop<E2>,
     impl E3Store: Store<E3>,
-    impl E3Drop: Drop<E3>
+    +Drop<E3>
 > of Store<(E0, E1, E2, E3)> {
     #[inline(always)]
     fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<(E0, E1, E2, E3)> {
@@ -649,10 +532,7 @@ impl TupleSize4Store<
     }
 }
 
-
-impl ResultStore<
-    T, E, impl TStore: Store<T>, impl EStore: Store<E>, impl TDrop: Drop<T>, impl EDrop: Drop<E>,
-> of Store<Result<T, E>> {
+impl ResultStore<T, E, +Store<T>, +Store<E>, +Drop<T>, +Drop<E>> of Store<Result<T, E>> {
     #[inline(always)]
     fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<Result<T, E>> {
         let idx = Store::<felt252>::read(address_domain, base)?;
@@ -719,11 +599,11 @@ impl ResultStore<
     }
     #[inline(always)]
     fn size() -> u8 {
-        1 + cmp::max(Store::<T>::size(), Store::<E>::size())
+        1 + core::cmp::max(Store::<T>::size(), Store::<E>::size())
     }
 }
 
-impl OptionStore<T, impl TStore: Store<T>, impl TDrop: Drop<T>,> of Store<Option<T>> {
+impl OptionStore<T, +Store<T>, +Drop<T>,> of Store<Option<T>> {
     #[inline(always)]
     fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<Option<T>> {
         let idx = Store::<felt252>::read(address_domain, base)?;
@@ -732,7 +612,7 @@ impl OptionStore<T, impl TStore: Store<T>, impl TDrop: Drop<T>,> of Store<Option
                 Option::Some(Store::read_at_offset(address_domain, base, 1_u8)?)
             )
         } else if idx == 0 {
-            starknet::SyscallResult::Ok(Option::None(()))
+            starknet::SyscallResult::Ok(Option::None)
         } else {
             starknet::SyscallResult::Err(array!['Incorrect index:'])
         }
@@ -744,9 +624,7 @@ impl OptionStore<T, impl TStore: Store<T>, impl TDrop: Drop<T>,> of Store<Option
                 Store::write(address_domain, base, 1)?;
                 Store::write_at_offset(address_domain, base, 1_u8, x)?;
             },
-            Option::None(_) => {
-                Store::write(address_domain, base, 0)?;
-            }
+            Option::None(_) => { Store::write(address_domain, base, 0)?; }
         };
         starknet::SyscallResult::Ok(())
     }
@@ -760,7 +638,7 @@ impl OptionStore<T, impl TStore: Store<T>, impl TDrop: Drop<T>,> of Store<Option
                 Option::Some(Store::read_at_offset(address_domain, base, offset + 1_u8)?)
             )
         } else if idx == 0 {
-            starknet::SyscallResult::Ok(Option::None(()))
+            starknet::SyscallResult::Ok(Option::None)
         } else {
             starknet::SyscallResult::Err(array!['Incorrect index:'])
         }
@@ -774,9 +652,7 @@ impl OptionStore<T, impl TStore: Store<T>, impl TDrop: Drop<T>,> of Store<Option
                 Store::write(address_domain, base, 1)?;
                 Store::write_at_offset(address_domain, base, 1_u8, x)?;
             },
-            Option::None(x) => {
-                Store::write(address_domain, base, 0)?;
-            }
+            Option::None(_x) => { Store::write(address_domain, base, 0)?; }
         };
         starknet::SyscallResult::Ok(())
     }
@@ -785,3 +661,153 @@ impl OptionStore<T, impl TStore: Store<T>, impl TDrop: Drop<T>,> of Store<Option
         1 + Store::<T>::size()
     }
 }
+
+/// Store for a `ByteArray`.
+///
+/// The layout of a `ByteArray` in storage is as follows:
+/// * Only the length in bytes is stored in the original address where the byte array is logically
+///   stored.
+/// * The actual data is stored in chunks of 256 `bytes31`s in another place in storage
+///   determined by the hash of:
+///   - The address storing the length of the array.
+///   - The chunk index.
+///   - The short string `ByteArray`.
+impl ByteArrayStore of Store<ByteArray> {
+    #[inline(always)]
+    fn read(address_domain: u32, base: StorageBaseAddress) -> SyscallResult<ByteArray> {
+        inner_read_byte_array(address_domain, storage_address_from_base(base))
+    }
+    #[inline(always)]
+    fn write(address_domain: u32, base: StorageBaseAddress, value: ByteArray) -> SyscallResult<()> {
+        inner_write_byte_array(address_domain, storage_address_from_base(base), value)
+    }
+    #[inline(always)]
+    fn read_at_offset(
+        address_domain: u32, base: StorageBaseAddress, offset: u8
+    ) -> SyscallResult<ByteArray> {
+        inner_read_byte_array(address_domain, storage_address_from_base_and_offset(base, offset))
+    }
+    #[inline(always)]
+    fn write_at_offset(
+        address_domain: u32, base: StorageBaseAddress, offset: u8, value: ByteArray
+    ) -> SyscallResult<()> {
+        inner_write_byte_array(
+            address_domain, storage_address_from_base_and_offset(base, offset), value
+        )
+    }
+    #[inline(always)]
+    fn size() -> u8 {
+        1
+    }
+}
+
+/// Returns a pointer to the `chunk`'th chunk of the byte array at `address`.
+/// The pointer is the `Poseidon` hash of:
+/// * `address` - The address of the ByteArray (where the length is stored).
+/// * `chunk` - The index of the chunk.
+/// * The short string `ByteArray` is used as the capacity argument of the sponge construction
+///   (domain separation).
+fn inner_byte_array_pointer(address: StorageAddress, chunk: felt252) -> StorageBaseAddress {
+    let (r, _, _) = core::poseidon::hades_permutation(address.into(), chunk, 'ByteArray'_felt252);
+    storage_base_address_from_felt252(r)
+}
+
+/// Reads a byte array from storage from domain `address_domain` and address `address`.
+/// The length of the byte array is read from `address` at domain `address_domain`.
+/// For more info read the documentation of `ByteArrayStore`.
+fn inner_read_byte_array(address_domain: u32, address: StorageAddress) -> SyscallResult<ByteArray> {
+    let len: usize =
+        match starknet::syscalls::storage_read_syscall(address_domain, address)?.try_into() {
+        Option::Some(x) => x,
+        Option::None => { return SyscallResult::Err(array!['Invalid ByteArray length']); },
+    };
+    let (mut remaining_full_words, pending_word_len) = core::DivRem::div_rem(
+        len, BYTES_IN_BYTES31.try_into().unwrap()
+    );
+    let mut chunk = 0;
+    let mut chunk_base = inner_byte_array_pointer(address, chunk);
+    let mut index_in_chunk = 0_u8;
+    let mut result: ByteArray = Default::default();
+    loop {
+        if remaining_full_words == 0 {
+            break Result::Ok(());
+        }
+        let value =
+            match starknet::syscalls::storage_read_syscall(
+                address_domain, storage_address_from_base_and_offset(chunk_base, index_in_chunk)
+            ) {
+            Result::Ok(value) => value,
+            Result::Err(err) => { break Result::Err(err); },
+        };
+        let value: bytes31 = match value.try_into() {
+            Option::Some(x) => x,
+            Option::None => { break Result::Err(array!['Invalid value']); },
+        };
+        result.data.append(value);
+        remaining_full_words -= 1;
+        index_in_chunk = match core::integer::u8_overflowing_add(index_in_chunk, 1) {
+            Result::Ok(x) => x,
+            Result::Err(_) => {
+                // After reading 256 `bytes31`s `index_in_chunk` will overflow and we move to the
+                // next chunk.
+                chunk += 1;
+                chunk_base = inner_byte_array_pointer(address, chunk);
+                0
+            },
+        };
+    }?;
+    if pending_word_len != 0 {
+        let pending_word = starknet::syscalls::storage_read_syscall(
+            address_domain, storage_address_from_base_and_offset(chunk_base, index_in_chunk)
+        )?;
+        result.pending_word = pending_word;
+        result.pending_word_len = pending_word_len;
+    }
+    Result::Ok(result)
+}
+
+/// Writes a byte array to storage to domain `address_domain` and address `address`.
+/// The length of the byte array is written to `address` at domain `address_domain`.
+/// For more info read the documentation of `ByteArrayStore`.
+fn inner_write_byte_array(
+    address_domain: u32, address: StorageAddress, value: ByteArray
+) -> SyscallResult<()> {
+    let len = value.len();
+    starknet::syscalls::storage_write_syscall(address_domain, address, len.into())?;
+    let mut full_words = value.data.span();
+    let mut chunk = 0;
+    let mut chunk_base = inner_byte_array_pointer(address, chunk);
+    let mut index_in_chunk = 0_u8;
+    loop {
+        let curr_value = match full_words.pop_front() {
+            Option::Some(x) => x,
+            Option::None => { break Result::Ok(()); },
+        };
+        match starknet::syscalls::storage_write_syscall(
+            address_domain,
+            storage_address_from_base_and_offset(chunk_base, index_in_chunk),
+            (*curr_value).into()
+        ) {
+            Result::Ok(_) => {},
+            Result::Err(err) => { break Result::Err(err); },
+        };
+        index_in_chunk = match core::integer::u8_overflowing_add(index_in_chunk, 1) {
+            Result::Ok(x) => x,
+            Result::Err(_) => {
+                // After writing 256 `byte31`s `index_in_chunk` will overflow and we move to the
+                // next chunk.
+                chunk += 1;
+                chunk_base = inner_byte_array_pointer(address, chunk);
+                0
+            },
+        };
+    }?;
+    if value.pending_word_len != 0 {
+        starknet::syscalls::storage_write_syscall(
+            address_domain,
+            storage_address_from_base_and_offset(chunk_base, index_in_chunk),
+            value.pending_word
+        )?;
+    }
+    Result::Ok(())
+}
diff --git a/corelib/src/starknet/syscalls.cairo b/corelib/src/starknet/syscalls.cairo
index 4f1254a..bf785a9 100644
--- a/corelib/src/starknet/syscalls.cairo
+++ b/corelib/src/starknet/syscalls.cairo
@@ -7,7 +7,7 @@ use starknet::{
 // `address` - The address of the called contract.
 // `entry_point_selector` - A selector for a function within that contract.
 // `calldata` - Call arguments.
-extern fn call_contract_syscall(
+pub extern fn call_contract_syscall(
     address: ContractAddress, entry_point_selector: felt252, calldata: Span<felt252>
 ) -> SyscallResult<Span<felt252>> implicits(GasBuiltin, System) nopanic;
 
@@ -17,7 +17,9 @@ extern fn call_contract_syscall(
 //     computation of the contract's address.
 // `calldata` - Call arguments for the constructor.
 // `deploy_from_zero` - Deploy the contract from the zero address.
-extern fn deploy_syscall(
+//
+// Returns the address of the deployed contract and the serialized return value of the constructor.
+pub extern fn deploy_syscall(
     class_hash: ClassHash,
     contract_address_salt: felt252,
     calldata: Span<felt252>,
@@ -27,25 +29,30 @@ extern fn deploy_syscall(
 // Emits an event.
 // `keys` - The keys of the event.
 // `data` - The data of the event.
-extern fn emit_event_syscall(
+pub extern fn emit_event_syscall(
     keys: Span<felt252>, data: Span<felt252>
 ) -> SyscallResult<()> implicits(GasBuiltin, System) nopanic;
 
 // Gets the block hash of the block with the given number.
-extern fn get_block_hash_syscall(
+pub extern fn get_block_hash_syscall(
     block_number: u64
 ) -> SyscallResult<felt252> implicits(GasBuiltin, System) nopanic;
 
 // Gets information about the current execution.
-extern fn get_execution_info_syscall() -> SyscallResult<Box<starknet::info::ExecutionInfo>> implicits(
-    GasBuiltin, System
-) nopanic;
+pub extern fn get_execution_info_syscall() -> SyscallResult<
+    Box<starknet::info::ExecutionInfo>
+> implicits(GasBuiltin, System) nopanic;
+
+// Gets information about the current execution, version 2.
+pub extern fn get_execution_info_v2_syscall() -> SyscallResult<
+    Box<starknet::info::v2::ExecutionInfo>
+> implicits(GasBuiltin, System) nopanic;
 
 // Calls the requested function in any previously declared class.
 // `class_hash` - The hash of the class you want to use.
 // `function_selector` - A selector for a function within that class.
 // `calldata` - Call arguments.
-extern fn library_call_syscall(
+pub extern fn library_call_syscall(
     class_hash: ClassHash, function_selector: felt252, calldata: Span<felt252>
 ) -> SyscallResult<Span<felt252>> implicits(GasBuiltin, System) nopanic;
 
@@ -53,7 +60,7 @@ extern fn library_call_syscall(
 // Sends a message to L1.
 // `to_address` - The recipient's L1 address.
 // `payload` - The content of the message.
-extern fn send_message_to_l1_syscall(
+pub extern fn send_message_to_l1_syscall(
     to_address: felt252, payload: Span<felt252>
 ) -> SyscallResult<()> implicits(GasBuiltin, System) nopanic;
 
@@ -62,7 +69,7 @@ extern fn send_message_to_l1_syscall(
 //     in the future it will enable access to address spaces with different data availability
 //     guarantees.
 // `address` - The address of the storage key to read.
-extern fn storage_read_syscall(
+pub extern fn storage_read_syscall(
     address_domain: u32, address: StorageAddress,
 ) -> SyscallResult<felt252> implicits(GasBuiltin, System) nopanic;
 
@@ -72,14 +79,14 @@ extern fn storage_read_syscall(
 //     guarantees.
 // `address` - The address of the storage key to write.
 // `value` - The value to write to the key.
-extern fn storage_write_syscall(
+pub extern fn storage_write_syscall(
     address_domain: u32, address: StorageAddress, value: felt252
 ) -> SyscallResult<()> implicits(GasBuiltin, System) nopanic;
 
 
 // Replaces the class hash of the current contract.
 // `class_hash` - The class hash that should replace the current one.
-extern fn replace_class_syscall(
+pub extern fn replace_class_syscall(
     class_hash: ClassHash
 ) -> SyscallResult<()> implicits(GasBuiltin, System) nopanic;
 
@@ -87,6 +94,6 @@ extern fn replace_class_syscall(
 // Computes the keccak of the input.
 // The system call does not add any padding and the input needs to be a multiple of 1088 bits
 // (== 17 u64 word).
-extern fn keccak_syscall(
+pub extern fn keccak_syscall(
     input: Span<u64>
 ) -> SyscallResult<u256> implicits(GasBuiltin, System) nopanic;
diff --git a/corelib/src/starknet/testing.cairo b/corelib/src/starknet/testing.cairo
index ed9b2c5..68258b0 100644
--- a/corelib/src/starknet/testing.cairo
+++ b/corelib/src/starknet/testing.cairo
@@ -1,95 +1,92 @@
 use starknet::ContractAddress;
-use array::ArrayTrait;
-use array::SpanTrait;
-use traits::Into;
+use core::array::ArrayTrait;
+use core::array::SpanTrait;
+use core::traits::Into;
 
 // A general cheatcode function used to simplify implementation of Starknet testing functions.
 // External users of the cairo crates can also implement their own cheatcodes
 // by injecting custom `CairoHintProcessor`.
-extern fn cheatcode<const selector: felt252>(
+pub extern fn cheatcode<const selector: felt252>(
     input: Span<felt252>
 ) -> Span<felt252> implicits() nopanic;
 
 // Set the block number to the provided value.
-fn set_block_number(block_number: u64) {
+pub fn set_block_number(block_number: u64) {
     cheatcode::<'set_block_number'>(array![block_number.into()].span());
 }
 
 // Set the caller address to the provided value.
-fn set_caller_address(address: ContractAddress) {
+pub fn set_caller_address(address: ContractAddress) {
     cheatcode::<'set_caller_address'>(array![address.into()].span());
 }
 
 // Set the contract address to the provided value.
-fn set_contract_address(address: ContractAddress) {
+pub fn set_contract_address(address: ContractAddress) {
     cheatcode::<'set_contract_address'>(array![address.into()].span());
 }
 
 // Set the sequencer address to the provided value.
-fn set_sequencer_address(address: ContractAddress) {
+pub fn set_sequencer_address(address: ContractAddress) {
     cheatcode::<'set_sequencer_address'>(array![address.into()].span());
 }
 
 // Set the block timestamp to the provided value.
-fn set_block_timestamp(block_timestamp: u64) {
+pub fn set_block_timestamp(block_timestamp: u64) {
     cheatcode::<'set_block_timestamp'>(array![block_timestamp.into()].span());
 }
 
 // Set the version to the provided value.
-fn set_version(version: felt252) {
+pub fn set_version(version: felt252) {
     cheatcode::<'set_version'>(array![version].span());
 }
 
 // Set the account contract address.
-fn set_account_contract_address(address: ContractAddress) {
+pub fn set_account_contract_address(address: ContractAddress) {
     cheatcode::<'set_account_contract_address'>(array![address.into()].span());
 }
 
 // Set the max fee.
-fn set_max_fee(fee: u128) {
+pub fn set_max_fee(fee: u128) {
     cheatcode::<'set_max_fee'>(array![fee.into()].span());
 }
 
 // Set the transaction hash.
-fn set_transaction_hash(hash: felt252) {
+pub fn set_transaction_hash(hash: felt252) {
     cheatcode::<'set_transaction_hash'>(array![hash].span());
 }
 
 // Set the chain id.
-fn set_chain_id(chain_id: felt252) {
+pub fn set_chain_id(chain_id: felt252) {
     cheatcode::<'set_chain_id'>(array![chain_id].span());
 }
 
 // Set the nonce.
-fn set_nonce(nonce: felt252) {
+pub fn set_nonce(nonce: felt252) {
     cheatcode::<'set_nonce'>(array![nonce].span());
 }
 
 // Set the signature.
-fn set_signature(signature: Span<felt252>) {
+pub fn set_signature(signature: Span<felt252>) {
     cheatcode::<'set_signature'>(signature);
 }
 
 // Pop the earliest unpopped logged event for the contract.
-fn pop_log_raw(address: ContractAddress) -> Option<(Span<felt252>, Span<felt252>)> {
+pub fn pop_log_raw(address: ContractAddress) -> Option<(Span<felt252>, Span<felt252>)> {
     let mut log = cheatcode::<'pop_log'>(array![address.into()].span());
-    Option::Some((serde::Serde::deserialize(ref log)?, serde::Serde::deserialize(ref log)?,))
+    Option::Some((Serde::deserialize(ref log)?, Serde::deserialize(ref log)?,))
 }
 
 // Pop the earliest unpopped logged event for the contract as the requested type.
-fn pop_log<T, impl TEvent: starknet::Event<T>>(address: ContractAddress) -> Option<T> {
+pub fn pop_log<T, +starknet::Event<T>>(address: ContractAddress) -> Option<T> {
     let (mut keys, mut data) = pop_log_raw(address)?;
     starknet::Event::deserialize(ref keys, ref data)
 }
 
 // TODO(Ilya): Decide if we limit the type of `to_address`.
 // Pop the earliest unpopped l2 to l1 message for the contract.
-fn pop_l2_to_l1_message(address: ContractAddress) -> Option<(felt252, Span<felt252>)> {
+pub fn pop_l2_to_l1_message(address: ContractAddress) -> Option<(felt252, Span<felt252>)> {
     let mut l2_to_l1_message = cheatcode::<'pop_l2_to_l1_message'>(array![address.into()].span());
     Option::Some(
-        (
-            serde::Serde::deserialize(ref l2_to_l1_message)?,
-            serde::Serde::deserialize(ref l2_to_l1_message)?,
-        )
+        (Serde::deserialize(ref l2_to_l1_message)?, Serde::deserialize(ref l2_to_l1_message)?,)
     )
 }
diff --git a/corelib/src/string.cairo b/corelib/src/string.cairo
new file mode 100644
index 0000000..7368771
--- /dev/null
+++ b/corelib/src/string.cairo
@@ -0,0 +1 @@
+pub trait StringLiteral<T>;
diff --git a/corelib/src/test.cairo b/corelib/src/test.cairo
index 6f41b0f..84931a9 100644
--- a/corelib/src/test.cairo
+++ b/corelib/src/test.cairo
@@ -1,17 +1,25 @@
 mod array_test;
 mod bool_test;
 mod box_test;
+mod byte_array_test;
 mod bytes31_test;
 mod cmp_test;
 mod dict_test;
 mod ec_test;
 mod felt_test;
+mod fmt_test;
 mod hash_test;
 mod integer_test;
 mod keccak_test;
+mod num_test;
 mod math_test;
+mod nullable_test;
+mod panics_test;
 mod plugins_test;
+mod print_test;
+mod result_test;
 mod secp256k1_test;
 mod secp256r1_test;
 mod test_utils;
 mod testing_test;
+mod to_byte_array_test;
diff --git a/corelib/src/test/array_test.cairo b/corelib/src/test/array_test.cairo
index deb3540..ce761c3 100644
--- a/corelib/src/test/array_test.cairo
+++ b/corelib/src/test/array_test.cairo
@@ -1,4 +1,4 @@
-use test::test_utils::{assert_eq, assert_ne};
+use core::test::test_utils::{assert_eq, assert_ne};
 
 #[test]
 fn test_array() {
@@ -23,7 +23,6 @@ fn test_array_out_of_bound_2() {
 }
 
 #[test]
-#[available_gas(100000)]
 fn test_array_clone() {
     let felt252_snap_array: @Array<felt252> = @array![10, 11, 12];
     let felt252_snap_array_clone = felt252_snap_array.clone();
@@ -75,7 +74,6 @@ fn test_slice_out_of_bound_2() {
 }
 
 #[test]
-#[available_gas(10000000)]
 fn test_equality() {
     let arr1 = array![];
     let arr2 = array![10, 11, 12];
@@ -100,3 +98,21 @@ fn test_equality() {
     assert(arr3 != arr5, 'arr3 == arr5');
     assert(arr4 != arr5, 'arr4 == arr5');
 }
+
+#[test]
+fn test_append() {
+    let mut arr = array![10, 11, 12];
+    arr.append(13);
+    assert(arr.len() == 4, 'Unexpected length');
+    assert_eq(arr[3], @13, 'Unexpected element');
+}
+
+#[test]
+fn test_append_span() {
+    let mut arr = array![10, 11, 12];
+    arr.append_span(arr.span());
+    assert(arr.len() == 6, 'Unexpected length');
+    assert_eq(arr[3], @10, 'Unexpected element');
+    assert_eq(arr[4], @11, 'Unexpected element');
+    assert_eq(arr[5], @12, 'Unexpected element');
+}
diff --git a/corelib/src/test/bool_test.cairo b/corelib/src/test/bool_test.cairo
index 881efb2..9cab5d6 100644
--- a/corelib/src/test/bool_test.cairo
+++ b/corelib/src/test/bool_test.cairo
@@ -1,4 +1,4 @@
-use test::test_utils::{assert_eq, assert_ne};
+use core::test::test_utils::{assert_eq, assert_ne};
 
 #[test]
 fn test_bool_operators() {
diff --git a/corelib/src/test/box_test.cairo b/corelib/src/test/box_test.cairo
index 7234951..d703e65 100644
--- a/corelib/src/test/box_test.cairo
+++ b/corelib/src/test/box_test.cairo
@@ -1,4 +1,4 @@
-use test::test_utils::{assert_eq, assert_ne};
+use core::test::test_utils::{assert_eq, assert_ne};
 
 #[test]
 fn test_box_unbox_felt252s() {
diff --git a/corelib/src/test/byte_array_test.cairo b/corelib/src/test/byte_array_test.cairo
index 64558fa..dd62b66 100644
--- a/corelib/src/test/byte_array_test.cairo
+++ b/corelib/src/test/byte_array_test.cairo
@@ -1,7 +1,6 @@
-use test::test_utils::{assert_eq, assert_ne};
+use core::test::test_utils::{assert_eq, assert_ne};
 
 #[test]
-#[available_gas(1000000)]
 fn test_append_byte() {
     let mut ba = Default::default();
     let mut c = 1_u8;
@@ -18,7 +17,6 @@ fn test_append_byte() {
 }
 
 #[test]
-#[available_gas(10000000)]
 fn test_append_word() {
     let mut ba = Default::default();
 
@@ -50,7 +48,6 @@ fn test_append_word() {
 }
 
 #[test]
-#[available_gas(1000000)]
 fn test_append() {
     let mut ba1 = test_byte_array_32();
     let ba2 = test_byte_array_32();
@@ -66,7 +63,6 @@ fn test_append() {
 
 // Same as test_append, but with `+=` instead of `append`.
 #[test]
-#[available_gas(1000000)]
 fn test_add_eq() {
     let mut ba1 = test_byte_array_32();
     let ba2 = test_byte_array_32();
@@ -81,7 +77,6 @@ fn test_add_eq() {
 }
 
 #[test]
-#[available_gas(1000000)]
 fn test_concat() {
     let ba1 = test_byte_array_32();
     let ba2 = test_byte_array_32();
@@ -97,7 +92,6 @@ fn test_concat() {
 
 // Same as test_concat, but with `+` instead of `concat`.
 #[test]
-#[available_gas(1000000)]
 fn test_add() {
     let ba1 = test_byte_array_32();
     let ba2 = test_byte_array_32();
@@ -113,7 +107,6 @@ fn test_add() {
 
 // Test concat/append, first byte array empty.
 #[test]
-#[available_gas(1000000)]
 fn test_concat_first_empty() {
     let ba1 = Default::default();
     let ba2 = test_byte_array_32();
@@ -126,7 +119,6 @@ fn test_concat_first_empty() {
 
 // Test concat/append, second byte array empty.
 #[test]
-#[available_gas(1000000)]
 fn test_concat_second_empty() {
     let ba1 = test_byte_array_32();
     let ba2 = Default::default();
@@ -139,7 +131,6 @@ fn test_concat_second_empty() {
 
 // Test concat/append, first byte array pending word is empty.
 #[test]
-#[available_gas(1000000)]
 fn test_concat_first_pending_0() {
     let ba1 = test_byte_array_31();
     let ba2 = test_byte_array_32();
@@ -155,7 +146,6 @@ fn test_concat_first_pending_0() {
 
 // Test concat/append, second byte array pending word is empty.
 #[test]
-#[available_gas(1000000)]
 fn test_concat_second_pending_0() {
     let ba1 = test_byte_array_32();
     let ba2 = test_byte_array_31();
@@ -171,7 +161,6 @@ fn test_concat_second_pending_0() {
 
 // Test concat/append, split index of the words of the second byte array is 16.
 #[test]
-#[available_gas(1000000)]
 fn test_concat_split_index_16() {
     let ba1 = test_byte_array_16();
     let ba2 = test_byte_array_32();
@@ -184,7 +173,6 @@ fn test_concat_split_index_16() {
 
 // Test concat/append, split index of the words of the second byte array is < 16, specifically 1.
 #[test]
-#[available_gas(1000000)]
 fn test_concat_split_index_lt_16() {
     let ba1 = test_byte_array_1();
     let ba2 = test_byte_array_32();
@@ -197,7 +185,6 @@ fn test_concat_split_index_lt_16() {
 
 // Test concat/append, split index of the words of the second byte array is > 16, specifically 30.
 #[test]
-#[available_gas(1000000)]
 fn test_concat_split_index_gt_16() {
     let ba1 = test_byte_array_30();
     let ba2 = test_byte_array_33();
@@ -213,7 +200,6 @@ fn test_concat_split_index_gt_16() {
 
 // Sum of the lengths of the pending words of both byte arrays is 31 (a full word).
 #[test]
-#[available_gas(1000000)]
 fn test_concat_pending_sum_up_to_full() {
     let ba1 = test_byte_array_32();
     let ba2 = test_byte_array_30();
@@ -230,7 +216,6 @@ fn test_concat_pending_sum_up_to_full() {
 // Sum of the lengths of the pending words of both byte arrays is 31+16.
 // That is, the pending words aggregate to a full word, and the last split index is 16.
 #[test]
-#[available_gas(1000000)]
 fn test_concat_pending_sum_up_to_more_than_word_16() {
     let ba1 = test_byte_array_17();
     let ba2 = test_byte_array_30();
@@ -244,7 +229,6 @@ fn test_concat_pending_sum_up_to_more_than_word_16() {
 // Sum of the lengths of the pending words of both byte arrays is in [32, 31+15].
 // That is, the pending words aggregate to a full word, and the last split index is <16.
 #[test]
-#[available_gas(1000000)]
 fn test_concat_pending_sum_up_to_more_than_word_lt16() {
     let ba1 = test_byte_array_2();
     let ba2 = test_byte_array_30();
@@ -258,7 +242,6 @@ fn test_concat_pending_sum_up_to_more_than_word_lt16() {
 // Sum of the lengths of the pending words of both byte arrays is >31+15
 // That is, the pending words aggregate to a full word, and the last split index is >16.
 #[test]
-#[available_gas(1000000)]
 fn test_concat_pending_sum_up_to_more_than_word_gt16() {
     let ba1 = test_byte_array_30();
     let ba2 = test_byte_array_30();
@@ -272,7 +255,6 @@ fn test_concat_pending_sum_up_to_more_than_word_gt16() {
 }
 
 #[test]
-#[available_gas(1000000)]
 fn test_len() {
     let ba: ByteArray = Default::default();
     assert(ba.len() == 0, 'wrong ByteArray len');
@@ -285,7 +267,6 @@ fn test_len() {
 }
 
 #[test]
-#[available_gas(100000000)]
 fn test_at_empty() {
     let ba: ByteArray = Default::default();
 
@@ -296,7 +277,6 @@ fn test_at_empty() {
 }
 
 #[test]
-#[available_gas(100000000)]
 fn test_at() {
     let mut ba = test_byte_array_31();
     ba.append(@test_byte_array_31());
@@ -324,7 +304,6 @@ fn test_at() {
 
 // Same as the previous test, but with [] instead of .at() (and without the out-of-bounds case).
 #[test]
-#[available_gas(100000000)]
 fn test_index_view() {
     let mut ba = test_byte_array_31();
     ba.append(@test_byte_array_31());
@@ -352,28 +331,26 @@ fn test_index_view() {
 // Test panic with [] in case of out-of-bounds
 #[test]
 #[should_panic(expected: ('Index out of bounds',))]
-#[available_gas(100000000)]
 fn test_index_view_out_of_bounds() {
     let mut ba = test_byte_array_31();
     ba.append(@test_byte_array_31());
     ba.append(@test_byte_array_17());
 
-    let x = ba[79];
+    let _x = ba[79];
 }
 
 #[test]
 fn test_string_literals() {
-    let ba: ByteArray = "12345"; // len < 16
-    let ba: ByteArray = "1234567890123456"; // len == 16
-    let ba: ByteArray = "123456789012345678"; // 16 < len < 31
-    let ba: ByteArray = "1234567890123456789012345678901"; // len == 31
-    let ba: ByteArray = "123456789012345678901234567890123"; // 31 < len < 47
-    let ba: ByteArray = "12345678901234567890123456789012345678901234567"; // len == 47
-    let ba: ByteArray = "123456789012345678901234567890123456789012345678"; // len > 47
+    let _ba: ByteArray = "12345"; // len < 16
+    let _ba: ByteArray = "1234567890123456"; // len == 16
+    let _ba: ByteArray = "123456789012345678"; // 16 < len < 31
+    let _ba: ByteArray = "1234567890123456789012345678901"; // len == 31
+    let _ba: ByteArray = "123456789012345678901234567890123"; // 31 < len < 47
+    let _ba: ByteArray = "12345678901234567890123456789012345678901234567"; // len == 47
+    let _ba: ByteArray = "123456789012345678901234567890123456789012345678"; // len > 47
 }
 
 #[test]
-#[available_gas(100000000)]
 fn test_equality() {
     let byte_array: ByteArray = "a";
     assert(@byte_array == @"a", 'Same strings are not equal');
@@ -402,7 +379,6 @@ fn test_equality() {
 }
 
 #[test]
-#[available_gas(100000000)]
 fn test_reverse() {
     // Arrays of length < 16
     let ba: ByteArray = "abc";
@@ -468,9 +444,38 @@ fn test_reverse() {
     assert_eq(@palindrome, @palindrome.rev(), 'palindrome is not a palindrome');
 }
 
+#[test]
+fn test_serde() {
+    let mut serialized = array![];
+    let ba: ByteArray = "";
+    let expected_serialized = array![0, 0, 0];
+    ba.serialize(ref serialized);
+    compare_spans(serialized.span(), expected_serialized.span());
+
+    let mut serialized = array![];
+    let ba: ByteArray = "hello";
+    let expected_serialized = array![
+        0, // data len
+         0x68656c6c6f, // pending_word
+         5 // pending_word_len
+    ];
+    ba.serialize(ref serialized);
+    compare_spans(serialized.span(), expected_serialized.span());
+
+    let mut serialized = array![];
+    let ba: ByteArray = "Long string, more than 31 characters.";
+    let expected_serialized = array![
+        1, // data len
+        0x4c6f6e6720737472696e672c206d6f7265207468616e203331206368617261, // data
+        0x63746572732e, // pending_word
+        6 // pending_word_len
+    ];
+    ba.serialize(ref serialized);
+    compare_spans(serialized.span(), expected_serialized.span());
+}
+
 // ========= Test helper functions =========
 
-use debug::PrintTrait;
 fn compare_byte_array(
     mut ba: @ByteArray, mut data: Span<felt252>, pending_word_len: usize, pending_word: felt252
 ) {
@@ -483,39 +488,33 @@ fn compare_byte_array(
             Option::Some(x) => {
                 let actual_word = (*x).into();
                 let expected_word = *data.pop_front().unwrap();
-                if actual_word != expected_word {
-                    'data_index:'.print();
-                    data_index.print();
-                    'expected word:'.print();
-                    expected_word.print();
-                    'actual word:'.print();
-                    actual_word.print();
-
-                    panic_with_felt252('wrong data');
-                }
+                assert_eq!(actual_word, expected_word, "wrong data for index: {data_index}");
             },
-            Option::None(_) => {
-                break;
-            }
+            Option::None(_) => { break; }
         }
         data_index += 1;
     };
 
-    if *ba.pending_word_len != pending_word_len {
-        'expected pending word len:'.print();
-        pending_word_len.print();
-        'actual pending word len:'.print();
-        (*ba.pending_word_len).print();
-        panic_with_felt252('wrong pending_word_len');
-    }
+    assert_eq!(*ba.pending_word_len, pending_word_len);
     let ba_pending_word_felt: felt252 = (*ba.pending_word).into();
-    if ba_pending_word_felt != pending_word {
-        'expected pending word:'.print();
-        pending_word.print();
-        'actual pending word:'.print();
-        ba_pending_word_felt.print();
-        panic_with_felt252('wrong pending_word');
-    }
+    assert_eq!(ba_pending_word_felt, pending_word);
+}
+
+fn compare_spans<T, +core::fmt::Debug<T>, +PartialEq<T>, +Copy<T>, +Drop<T>>(
+    mut a: Span<T>, mut b: Span<T>
+) {
+    assert_eq!(a.len(), b.len());
+    let mut index = 0;
+    loop {
+        match a.pop_front() {
+            Option::Some(current_a) => {
+                let current_b = b.pop_front().unwrap();
+                assert_eq!(*current_a, *current_b, "wrong data for index: {index}");
+            },
+            Option::None(_) => { break; }
+        }
+        index += 1;
+    };
 }
 
 fn test_byte_array_1() -> ByteArray {
diff --git a/corelib/src/test/bytes31_test.cairo b/corelib/src/test/bytes31_test.cairo
index 825300c..9176c2b 100644
--- a/corelib/src/test/bytes31_test.cairo
+++ b/corelib/src/test/bytes31_test.cairo
@@ -1,52 +1,52 @@
-use bytes_31::split_bytes31;
+use core::bytes_31::{split_bytes31, bytes31_const};
 
 const POW_2_248: felt252 = 0x100000000000000000000000000000000000000000000000000000000000000;
 
 #[test]
 fn test_at() {
     let b1 = bytes31_const::<0x01>();
-    assert(b1.at(0) == 0x01, 'wrong byte at index 0');
+    assert_eq!(b1.at(0), 0x01);
 
     let b17 = bytes31_const::<0x0102030405060708090a0b0c0d0e0f1011>();
-    assert(b17.at(0) == 0x11, 'wrong byte at index 0');
-    assert(b17.at(1) == 0x10, 'wrong byte at index 1');
-    assert(b17.at(2) == 0x0f, 'wrong byte at index 2');
-    assert(b17.at(14) == 0x03, 'wrong byte at index 14');
-    assert(b17.at(15) == 0x02, 'wrong byte at index 15');
-    assert(b17.at(16) == 0x01, 'wrong byte at index 16');
+    assert_eq!(b17.at(0), 0x11);
+    assert_eq!(b17.at(1), 0x10);
+    assert_eq!(b17.at(2), 0x0f);
+    assert_eq!(b17.at(14), 0x03);
+    assert_eq!(b17.at(15), 0x02);
+    assert_eq!(b17.at(16), 0x01);
 
     let b31 = bytes31_const::<0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f>();
-    assert(b31.at(0) == 0x1f, 'wrong byte at index 0');
-    assert(b31.at(1) == 0x1e, 'wrong byte at index 1');
-    assert(b31.at(2) == 0x1d, 'wrong byte at index 2');
-    assert(b31.at(14) == 0x11, 'wrong byte at index 14');
-    assert(b31.at(15) == 0x10, 'wrong byte at index 15');
-    assert(b31.at(16) == 0x0f, 'wrong byte at index 16');
-    assert(b31.at(17) == 0x0e, 'wrong byte at index 17');
-    assert(b31.at(29) == 0x02, 'wrong byte at index 29');
-    assert(b31.at(30) == 0x01, 'wrong byte at index 30');
+    assert_eq!(b31.at(0), 0x1f);
+    assert_eq!(b31.at(1), 0x1e);
+    assert_eq!(b31.at(2), 0x1d);
+    assert_eq!(b31.at(14), 0x11);
+    assert_eq!(b31.at(15), 0x10);
+    assert_eq!(b31.at(16), 0x0f);
+    assert_eq!(b31.at(17), 0x0e);
+    assert_eq!(b31.at(29), 0x02);
+    assert_eq!(b31.at(30), 0x01);
 }
 
 // Same as the previous test, but with [] instead of .at()
 #[test]
 fn test_index_view() {
     let b1 = bytes31_const::<0x01>();
-    assert(b1[0] == 0x01, 'wrong byte at index 0');
+    assert_eq!(b1[0], 0x01);
 
     let b17 = bytes31_const::<0x0102030405060708090a0b0c0d0e0f1011>();
-    assert(b17[0] == 0x11, 'wrong byte at index 0');
-    assert(b17[1] == 0x10, 'wrong byte at index 1');
-    assert(b17[2] == 0x0f, 'wrong byte at index 2');
-    assert(b17[14] == 0x03, 'wrong byte at index 14');
-    assert(b17[15] == 0x02, 'wrong byte at index 15');
-    assert(b17[16] == 0x01, 'wrong byte at index 16');
+    assert_eq!(b17[0], 0x11);
+    assert_eq!(b17[1], 0x10);
+    assert_eq!(b17[2], 0x0f);
+    assert_eq!(b17[14], 0x03);
+    assert_eq!(b17[15], 0x02);
+    assert_eq!(b17[16], 0x01);
 
     let b31 = bytes31_const::<0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f>();
-    assert(b31[0] == 0x1f, 'wrong byte at index 0');
-    assert(b31[1] == 0x1e, 'wrong byte at index 1');
-    assert(b31[2] == 0x1d, 'wrong byte at index 2');
-    assert(b31[14] == 0x11, 'wrong byte at index 14');
-    assert(b31[15] == 0x10, 'wrong byte at index 15');
+    assert_eq!(b31[0], 0x1f);
+    assert_eq!(b31[1], 0x1e);
+    assert_eq!(b31[2], 0x1d);
+    assert_eq!(b31[14], 0x11);
+    assert_eq!(b31[15], 0x10);
     assert(b31[16] == 0x0f, 'wrong byte at index 16');
     assert(b31[17] == 0x0e, 'wrong byte at index 17');
     assert(b31[29] == 0x02, 'wrong byte at index 29');
diff --git a/corelib/src/test/cmp_test.cairo b/corelib/src/test/cmp_test.cairo
index 91e964a..2b21155 100644
--- a/corelib/src/test/cmp_test.cairo
+++ b/corelib/src/test/cmp_test.cairo
@@ -1,5 +1,5 @@
-use cmp::{max, min};
-use test::test_utils::{assert_eq, assert_ne};
+use core::cmp::{max, min};
+use core::test::test_utils::{assert_eq, assert_ne};
 
 // Integer tests
 
diff --git a/corelib/src/test/dict_test.cairo b/corelib/src/test/dict_test.cairo
index ff3c1eb..bee920c 100644
--- a/corelib/src/test/dict_test.cairo
+++ b/corelib/src/test/dict_test.cairo
@@ -1,5 +1,6 @@
-use dict::Felt252DictEntryTrait;
-use test::test_utils::{assert_eq, assert_ne};
+use core::dict::Felt252DictEntryTrait;
+use core::test::test_utils::{assert_eq, assert_ne};
+use core::nullable;
 
 #[test]
 fn test_dict_new() -> Felt252Dict<felt252> {
@@ -9,14 +10,14 @@ fn test_dict_new() -> Felt252Dict<felt252> {
 #[test]
 fn test_dict_squash_empty() {
     let mut dict: Felt252Dict<felt252> = Default::default();
-    let squashed_dict = dict.squash();
+    let _squashed_dict = dict.squash();
 }
 
 #[test]
 fn test_dict_default_val() {
     let mut dict: Felt252Dict = Default::default();
     let default_val = dict.get(0);
-    assert_eq(@default_val, @0, 'default_val == 0');
+    assert_eq!(default_val, 0);
 }
 
 #[test]
@@ -27,9 +28,9 @@ fn test_dict_write_read() {
     let val10 = dict[10];
     let val11 = dict[11];
     let val12 = dict[12];
-    assert_eq(@val10, @110, 'dict[10] == 110');
-    assert_eq(@val11, @111, 'dict[11] == 111');
-    assert_eq(@val12, @0, 'default_val == 0');
+    assert_eq!(val10, 110);
+    assert_eq!(val11, 111);
+    assert_eq!(val12, 0);
 }
 
 #[test]
@@ -37,18 +38,18 @@ fn test_dict_entry() {
     let mut dict = Default::default();
     dict.insert(10, 110);
     let (entry, value) = dict.entry(10);
-    assert_eq(@value, @110, 'dict[10] == 110');
+    assert_eq!(value, 110);
     let mut dict = entry.finalize(11);
-    assert_eq(@dict[10], @11, 'dict[10] == 11');
+    assert_eq!(dict[10], 11);
 }
 
 #[test]
 fn test_dict_entry_uninitialized() {
     let mut dict = Default::default();
     let (entry, value) = dict.entry(10);
-    assert_eq(@value, @0_felt252, 'dict[10] == 0');
+    assert_eq!(value, 0_felt252);
     let mut dict = entry.finalize(110);
-    assert_eq(@dict[10], @110, 'dict[10] == 110');
+    assert_eq!(dict[10], 110);
 }
 
 #[test]
@@ -56,11 +57,11 @@ fn test_dict_update_twice() {
     let mut dict = Default::default();
     dict.insert(10, 110);
     let (entry, value) = dict.entry(10);
-    assert_eq(@value, @110, 'dict[10] == 110');
+    assert_eq!(value, 110);
     dict = entry.finalize(11);
-    assert_eq(@dict[10], @11, 'dict[10] == 11');
+    assert_eq!(dict[10], 11);
     let (entry, value) = dict.entry(10);
-    assert_eq(@value, @11, 'dict[10] == 11');
+    assert_eq!(value, 11);
     dict = entry.finalize(12);
     assert_eq(@dict[10], @12, 'dict[10] == 12');
 }
@@ -73,7 +74,7 @@ fn test_dict_update_twice() {
 fn test_dict_entry_destruct() {
     let mut dict = Default::default();
     dict.insert(10, 110);
-    let (entry, value) = dict.entry(10);
+    let (_entry, _value) = dict.entry(10);
 }
 
 const KEY1: felt252 = 10;
@@ -107,8 +108,8 @@ fn test_dict_big_keys() {
 #[test]
 fn test_dict_of_nullable() {
     let mut dict = Default::default();
-    dict.insert(10, nullable_from_box(BoxTrait::new(1)));
-    dict.insert(11, nullable_from_box(BoxTrait::new(2)));
+    dict.insert(10, nullable::nullable_from_box(BoxTrait::new(1)));
+    dict.insert(11, nullable::nullable_from_box(BoxTrait::new(2)));
     let val10 = dict[10].deref();
     let val11 = dict[11].deref();
     let val12 = dict[12];
@@ -122,15 +123,28 @@ fn test_dict_of_nullable() {
         'default_val == null'
     );
 }
-// TODO(lior): Re-enable the test once Dict of bools are supported.
-// #[test]
-// fn test_bool_dict() {
-//     let mut bool_dict: Felt252Dict<bool> = Felt252DictTrait::new();
-//     let squashed_dict = bool_dict.squash();
-//     let mut bool_dict: Felt252Dict<bool> = Felt252DictTrait::new();
-//     assert(!bool_dict.get(0), 'default_val != false');
-//     bool_dict.insert(1, true);
-//     assert(bool_dict.get(1), 'bool_dict[1] != true');
-// }
 
+#[test]
+fn test_bool_dict() {
+    let mut bool_dict: Felt252Dict<bool> = Default::default();
+    let _squashed_dict = bool_dict.squash();
+    let mut bool_dict: Felt252Dict<bool> = Default::default();
+    assert(!bool_dict.get(0), 'default_val != false');
+    bool_dict.insert(1, true);
+    assert(bool_dict.get(1), 'bool_dict[1] != true');
+}
+
+#[test]
+fn test_array_dict() {
+    let mut dict = Default::default();
+    dict.insert(10, NullableTrait::new(array![1, 2, 3]));
+    let (entry, value) = dict.entry(10);
+    assert_eq(@value.deref(), @array![1, 2, 3], 'dict[10] == [1, 2, 3]');
+    dict = entry.finalize(NullableTrait::new(array![4, 5]));
+    let (entry, value) = dict.entry(10);
+    assert_eq(@value.deref(), @array![4, 5], 'dict[10] == [4, 5]');
+    dict = entry.finalize(nullable::null());
+    let (_entry, value) = dict.entry(10);
+    assert(value.is_null(), 'dict[10] == null');
+}
 
diff --git a/corelib/src/test/ec_test.cairo b/corelib/src/test/ec_test.cairo
index b5a57cf..249522a 100644
--- a/corelib/src/test/ec_test.cairo
+++ b/corelib/src/test/ec_test.cairo
@@ -1,7 +1,8 @@
-use ec::{EcPointTrait, EcStateTrait};
-use option::OptionTrait;
-use test::test_utils::{assert_eq, assert_ne};
-use traits::{Into, TryInto};
+use core::ec::{EcPoint, EcPointTrait, EcStateTrait};
+use core::ecdsa;
+use core::option::OptionTrait;
+use core::test::test_utils::{assert_eq, assert_ne};
+use core::traits::{Into, TryInto};
 
 #[test]
 #[should_panic]
@@ -52,7 +53,8 @@ fn test_ec_operations() {
     assert_eq(@sub_y, @y, 'bad y for 2p - p');
 
     // Compute `p - p`.
-    assert((p - p).try_into().is_none(), 'p - p did not return 0.');
+    let p_diff: Option<NonZero<EcPoint>> = (p - p).try_into();
+    assert(p_diff.is_none(), 'p - p did not return 0.');
 
     // Compute `(-p) - p`.
     let (sub2_x, sub2_y) = (-p - p).try_into().unwrap().coordinates();
@@ -110,7 +112,6 @@ fn test_ecdsa() {
 }
 
 #[test]
-#[available_gas(100000000)]
 fn test_ecdsa_recover_public_key() {
     let message_hash = 0x503f4bea29baee10b22a7f10bdc82dda071c977c1f25b8f3973d34e6b03b2c;
     let signature_r = 0xbe96d72eb4f94078192c2e84d5230cde2a70f4b45c8797e2c907acff5060bb;
diff --git a/corelib/src/test/felt_test.cairo b/corelib/src/test/felt_test.cairo
index 52b65af..1276e8c 100644
--- a/corelib/src/test/felt_test.cairo
+++ b/corelib/src/test/felt_test.cairo
@@ -1,4 +1,4 @@
-use test::test_utils::{assert_eq, assert_ne};
+use core::test::test_utils::{assert_eq, assert_ne};
 
 #[test]
 fn test_felt252_operators() {
diff --git a/corelib/src/test/fmt_test.cairo b/corelib/src/test/fmt_test.cairo
new file mode 100644
index 0000000..57fabbf
--- /dev/null
+++ b/corelib/src/test/fmt_test.cairo
@@ -0,0 +1,80 @@
+#[test]
+fn test_format() {
+    let ba: ByteArray = "hello";
+    assert(format!("{}", ba) == ba, 'byte array bad formatting');
+    assert(format!("{}", 97_felt252) == "97", 'felt252 bad formatting');
+    assert(format!("{}", 97_usize) == "97", 'usize bad formatting');
+    assert(format!("{}", 34 - 5) == "29", 'expression bad formatting');
+    assert(format!("no_format") == "no_format", 'no args bad formatting');
+    assert(format!("{}{}", 12_usize, 14_u32) == "1214", 'two args bad formatting');
+    assert(format!("{0}{0}", 12_usize) == "1212", 'positional bad formatting');
+    assert(format!("{}{1}", 12_usize, 14_u32) == "1214", 'positional mix bad formatting');
+    assert(format!("{ba}_{}_{}_{1}", 12, 14_u32) == "hello_12_14_14", 'full mix bad formatting');
+    assert(format!("{{{{}}}}") == "{{}}", 'special cases bad formatting');
+    let nz_value: NonZero<felt252> = 1.try_into().unwrap();
+    assert(format!("{}", nz_value) == "1", 'non zero bad formatting');
+}
+
+#[derive(Debug, Drop)]
+struct StructExample {
+    felt_value: felt252,
+    bool_value: bool,
+    byte_array_value: ByteArray,
+    enum_value: EnumExample,
+}
+
+#[derive(Debug, Drop)]
+enum EnumExample {
+    Empty,
+    FeltValue: felt252,
+    BoolValue: bool,
+}
+
+#[test]
+fn test_format_debug() {
+    let ba: ByteArray = "hello";
+    assert(format!("{:?}", ba) == "\"hello\"", 'byte array bad formatting');
+    assert(format!("{:?}", 97_felt252) == "97", 'felt252 bad formatting');
+    assert(format!("{:?}", 97_usize) == "97", 'usize bad formatting');
+    assert(format!("{:?}{:?}", 12_usize, 14_u32) == "1214", 'two args bad formatting');
+    assert(format!("{0:?}{0:?}", 12_usize) == "1212", 'positional bad formatting');
+    assert(format!("{:?}{1:?}", 12_usize, 14_u32) == "1214", 'positional mix bad formatting');
+    assert(
+        format!("{ba:?}_{:?}_{:?}_{1:?}", 12, 14_u32) == "\"hello\"_12_14_14",
+        'full mix bad formatting'
+    );
+    assert(
+        format!("{:?}", EnumExample::Empty) == "EnumExample::Empty(())", 'bad enum empty derive fmt'
+    );
+    assert(
+        format!("{:?}", EnumExample::FeltValue(4)) == "EnumExample::FeltValue(4)",
+        'bad derive enum fmt'
+    );
+    assert(
+        format!(
+            "{:?}",
+            StructExample {
+                felt_value: 6,
+                bool_value: false,
+                byte_array_value: "ByteArray",
+                enum_value: EnumExample::BoolValue(true)
+            }
+        ) == "StructExample { felt_value: 6, bool_value: false, byte_array_value: \"ByteArray\", enum_value: EnumExample::BoolValue(true) }",
+        'bad derive struct formatting'
+    );
+    assert(
+        format!("{:?}", ((), (1,), (2, 3), (4, 5, 6))) == "((), (1,), (2, 3), (4, 5, 6))",
+        'bad tuple fmt'
+    );
+    assert(format!("{:?}", core::box::BoxTrait::new(1)) == "&1", 'bad box fmt');
+    assert(
+        format!("{:?}", core::nullable::NullableTrait::new(1)) == "&1", 'bad nullable value fmt'
+    );
+    assert(format!("{:?}", core::nullable::null::<felt252>()) == "null", 'bad null fmt');
+}
+
+#[test]
+fn test_array_debug() {
+    let arr = array![1, 2, 3];
+    assert(format!("{:?}", arr) == "[1, 2, 3]", 'bad array fmt');
+}
diff --git a/corelib/src/test/hash_test.cairo b/corelib/src/test/hash_test.cairo
index cc7a7a1..93f9eb9 100644
--- a/corelib/src/test/hash_test.cairo
+++ b/corelib/src/test/hash_test.cairo
@@ -1,9 +1,11 @@
-use test::test_utils::{assert_eq, assert_ne};
+use core::test::test_utils::{assert_eq, assert_ne};
+use core::hash::{HashStateTrait, HashStateExTrait};
+use core::poseidon::PoseidonTrait;
 
 #[test]
 fn test_pedersen_hash() {
     assert_eq(
-        @pedersen::pedersen(1, 2),
+        @core::pedersen::pedersen(1, 2),
         @2592987851775965742543459319508348457290966253241455514226127639100457844774,
         'Wrong hash value'
     );
@@ -11,7 +13,7 @@ fn test_pedersen_hash() {
 
 #[test]
 fn test_poseidon_hades_permutation() {
-    let (s0, s1, s2) = poseidon::hades_permutation(1, 2, 3);
+    let (s0, s1, s2) = core::poseidon::hades_permutation(1, 2, 3);
     assert_eq(
         @s0,
         @442682200349489646213731521593476982257703159825582578145778919623645026501,
@@ -30,19 +32,58 @@ fn test_poseidon_hades_permutation() {
 }
 
 #[test]
-#[available_gas(300000)]
 fn test_poseidon_hash_span() {
     // Test odd number of inputs.
     assert_eq(
-        @poseidon::poseidon_hash_span(array![1, 2, 3].span()),
+        @core::poseidon::poseidon_hash_span(array![1, 2, 3].span()),
         @0x2f0d8840bcf3bc629598d8a6cc80cb7c0d9e52d93dab244bbf9cd0dca0ad082,
         'wrong result'
     );
 
     // Test even number of inputs.
     assert_eq(
-        @poseidon::poseidon_hash_span(array![1, 2, 3, 4].span()),
+        @core::poseidon::poseidon_hash_span(array![1, 2, 3, 4].span()),
         @0x26e3ad8b876e02bc8a4fc43dad40a8f81a6384083cabffa190bcf40d512ae1d,
         'wrong result'
     );
 }
+
+#[derive(Hash)]
+enum EnumForHash {
+    First,
+    Second: felt252,
+    Third: (felt252, felt252),
+}
+
+#[derive(Hash)]
+struct StructForHash {
+    first: (),
+    second: felt252,
+    third: (felt252, felt252),
+}
+
+#[test]
+fn test_user_defined_hash() {
+    assert_eq(
+        @PoseidonTrait::new().update_with(EnumForHash::First).finalize(),
+        @PoseidonTrait::new().update(0).finalize(),
+        'Bad hash of EnumForHash::First',
+    );
+    assert_eq(
+        @PoseidonTrait::new().update_with(EnumForHash::Second(5)).finalize(),
+        @PoseidonTrait::new().update(1).update(5).finalize(),
+        'Bad hash of EnumForHash::Second',
+    );
+    assert_eq(
+        @PoseidonTrait::new().update_with(EnumForHash::Third((6, 8))).finalize(),
+        @PoseidonTrait::new().update(2).update(6).update(8).finalize(),
+        'Bad hash of EnumForHash::Third',
+    );
+    assert_eq(
+        @PoseidonTrait::new()
+            .update_with(StructForHash { first: (), second: 10, third: (6, 17) })
+            .finalize(),
+        @PoseidonTrait::new().update(10).update(6).update(17).finalize(),
+        'Bad hash of StructForHash',
+    );
+}
diff --git a/corelib/src/test/integer_test.cairo b/corelib/src/test/integer_test.cairo
index 7f3ce08..03e3f60 100644
--- a/corelib/src/test/integer_test.cairo
+++ b/corelib/src/test/integer_test.cairo
@@ -1,8 +1,11 @@
-use integer::{
-    BoundedInt, u128_wrapping_sub, u16_sqrt, u32_sqrt, u64_sqrt, u8_sqrt, u512, u256_wide_mul,
-    u256_as_non_zero, u512_safe_div_rem_by_u256, u128_as_non_zero
+use core::{
+    integer,
+    integer::{
+        BoundedInt, u128_sqrt, u128_wrapping_sub, u16_sqrt, u256_sqrt, u256_wide_mul, u32_sqrt,
+        u512_safe_div_rem_by_u256, u512, u64_sqrt, u8_sqrt
+    }
 };
-use test::test_utils::{assert_eq, assert_ne, assert_le, assert_lt, assert_gt, assert_ge};
+use core::test::test_utils::{assert_eq, assert_ne, assert_le, assert_lt, assert_gt, assert_ge};
 
 #[test]
 fn test_u8_operators() {
@@ -908,7 +911,6 @@ fn test_u256_sqrt() {
 
 #[test]
 fn test_u256_try_into_felt252() {
-    let FELT252_PRIME = 0x800000000000011000000000000000000000000000000000000000000000001_u256;
     assert_eq(@1_u256.try_into().unwrap(), @1_felt252, '1 == 1'_felt252);
     assert_eq(
         @0x800000000000011000000000000000000000000000000000000000000000000_u256.try_into().unwrap(),
@@ -931,39 +933,211 @@ fn test_u256_try_into_felt252() {
     assert(f.is_none(), 'prime+2**128 is not felt252');
 }
 
-fn cast_must_pass<
+/// Checks if `b` is out of range of `A`.
+fn is_out_of_range<A, B, +Drop<A>, +TryInto<B, A>>(b: B) -> bool {
+    let no_a: Option<A> = b.try_into();
+    no_a.is_none()
+}
+
+/// Checks if `SubType` is trivially castable to `SuperType`.
+fn cast_subtype_valid<
+    SubType,
+    SuperType,
+    +Drop<SubType>,
+    +Drop<SuperType>,
+    +Copy<SubType>,
+    +Copy<SuperType>,
+    +BoundedInt<SubType>,
+    +PartialEq<SubType>,
+    +PartialEq<SuperType>,
+    +Into<SubType, SuperType>,
+    +TryInto<SuperType, SubType>
+>() -> bool {
+    let max_sub: SubType = BoundedInt::max();
+    let max_sub_as_super: SuperType = max_sub.into();
+    let min_sub: SubType = BoundedInt::min();
+    let min_sub_as_super: SuperType = min_sub.into();
+    min_sub_as_super.try_into().unwrap() == min_sub
+        && max_sub_as_super.try_into().unwrap() == max_sub
+}
+
+/// Checks that `A::max()` is castable to `B`, and `A::max() + 1` is in `B`s range, and not
+/// castable back to `A`.
+fn validate_max_strictly_contained<
     A,
     B,
-    impl DropA: Drop<A>,
-    impl DropB: Drop<B>,
-    impl CopyB: Copy<B>,
-    impl CopyA: Copy<A>,
-    impl APartialEq: PartialEq<A>,
-    impl BPartialEq: PartialEq<B>,
-    impl BIA: BoundedInt<A>,
-    impl BIB: BoundedInt<B>,
-    impl IAB: Into<A, B>,
-    impl IBA: TryInto<B, A>
+    +Drop<A>,
+    +Drop<B>,
+    +Copy<A>,
+    +Copy<B>,
+    +Add<B>,
+    +BoundedInt<A>,
+    +PartialEq<A>,
+    +PartialEq<B>,
+    +TryInto<A, B>,
+    +TryInto<B, A>,
+    +TryInto<felt252, B>
 >(
-    ui: A, uj: B
-) -> bool {
-    uj == ui.into()
-        && ui == uj.try_into().unwrap()
-        && BoundedInt::<B>::min() == BoundedInt::<A>::min().into()
-        && BoundedInt::<A>::min() == BoundedInt::<B>::min().try_into().unwrap()
+    err: felt252
+) {
+    let max_a: A = BoundedInt::max();
+    let max_a_as_b: B = max_a.try_into().expect(err);
+    assert(Option::Some(max_a) == max_a_as_b.try_into(), err);
+    assert(is_out_of_range::<A>(max_a_as_b + 1.try_into().unwrap()), err);
 }
+
+/// Checks that `A::min()` is castable to `B`, and `A::min() - 1` is in `B`s range, and not
+/// castable back to `A`.
+fn validate_min_strictly_contained<
+    A,
+    B,
+    +Drop<A>,
+    +Drop<B>,
+    +Copy<A>,
+    +Copy<B>,
+    +Sub<B>,
+    +BoundedInt<A>,
+    +PartialEq<A>,
+    +PartialEq<B>,
+    +TryInto<A, B>,
+    +TryInto<B, A>,
+    +TryInto<felt252, B>
+>(
+    err: felt252
+) {
+    let min_sub: A = BoundedInt::min();
+    let min_sub_as_super: B = min_sub.try_into().expect(err);
+    assert(Option::Some(min_sub) == min_sub_as_super.try_into(), err);
+    assert(is_out_of_range::<A>(min_sub_as_super - 1.try_into().unwrap()), err);
+}
+
+/// Checks that castings from `SubType` to `SuperType` are correct around the bounds, where
+/// `SubType` is strictly contained (in both bounds) in `SuperType`.
+fn validate_cast_bounds_strictly_contained<
+    SubType,
+    SuperType,
+    +Drop<SubType>,
+    +Drop<SuperType>,
+    +Copy<SubType>,
+    +Copy<SuperType>,
+    +Add<SuperType>,
+    +Sub<SuperType>,
+    +BoundedInt<SubType>,
+    +PartialEq<SubType>,
+    +PartialEq<SuperType>,
+    +Into<SubType, SuperType>,
+    +TryInto<SuperType, SubType>,
+    +TryInto<felt252, SuperType>
+>(
+    err: felt252
+) {
+    assert(cast_subtype_valid::<SubType, SuperType>(), err);
+    validate_min_strictly_contained::<SubType, SuperType>(err);
+    validate_max_strictly_contained::<SubType, SuperType>(err);
+}
+
+/// Checks that castings from `SubType` to `SuperType` are correct around the bounds, where
+/// `SubType` has the same min as `SuperType`, but has a lower max.
+fn validate_cast_bounds_contained_same_min<
+    SubType,
+    SuperType,
+    +Drop<SubType>,
+    +Drop<SuperType>,
+    +Copy<SubType>,
+    +Copy<SuperType>,
+    +Add<SuperType>,
+    +Sub<SuperType>,
+    +BoundedInt<SubType>,
+    +BoundedInt<SuperType>,
+    +PartialEq<SubType>,
+    +PartialEq<SuperType>,
+    +Into<SubType, SuperType>,
+    +TryInto<SuperType, SubType>,
+    +TryInto<felt252, SuperType>
+>(
+    err: felt252
+) {
+    assert(cast_subtype_valid::<SubType, SuperType>(), err);
+    assert(BoundedInt::<SubType>::min().into() == BoundedInt::<SuperType>::min(), err);
+    validate_max_strictly_contained::<SubType, SuperType>(err);
+}
+
+/// Checks that castings from `A` to `B` are correct around the bounds.
+/// Assumes that the ordering of the bounds is: `a_min < b_min < a_max < b_max`.
+fn validate_cast_bounds_overlapping<
+    A,
+    B,
+    +Drop<A>,
+    +Drop<B>,
+    +Copy<A>,
+    +Copy<B>,
+    +Sub<A>,
+    +Add<B>,
+    +BoundedInt<A>,
+    +BoundedInt<B>,
+    +PartialEq<A>,
+    +PartialEq<B>,
+    +TryInto<A, B>,
+    +TryInto<B, A>,
+    +TryInto<felt252, A>,
+    +TryInto<felt252, B>
+>(
+    err: felt252
+) {
+    validate_min_strictly_contained::<B, A>(err);
+    validate_max_strictly_contained::<A, B>(err);
+}
+
 #[test]
 fn proper_cast() {
-    assert(cast_must_pass(0xFF_u8, 0xFF_u16), 'u8 to_and_fro u16');
-    assert(cast_must_pass(0xFF_u8, 0xFF_u32), 'u8 to_and_fro u32');
-    assert(cast_must_pass(0xFF_u8, 0xFF_u64), 'u8 to_and_fro u64');
-    assert(cast_must_pass(0xFF_u8, 0xFF_u128), 'u8 to_and_fro u128');
-    assert(cast_must_pass(0xFFFF_u16, 0xFFFF_u32), 'u16 to_and_fro u32');
-    assert(cast_must_pass(0xFFFF_u16, 0xFFFF_u64), 'u16 to_and_fro u64');
-    assert(cast_must_pass(0xFFFF_u16, 0xFFFF_u128), 'u16 to_and_fro u128');
-    assert(cast_must_pass(0xFFFFFFFF_u32, 0xFFFFFFFF_u64), 'u32 to_and_fro u64');
-    assert(cast_must_pass(0xFFFFFFFF_u32, 0xFFFFFFFF_u128), 'u32 to_and_fro u128');
-    assert(cast_must_pass(0xFFFFFFFFFFFFFFFF_u64, 0xFFFFFFFFFFFFFFFF_u128), 'u64 to_and_fro u128');
+    validate_cast_bounds_contained_same_min::<u8, u16>('u8 u16 casts');
+    validate_cast_bounds_contained_same_min::<u8, u32>('u8 u32 casts');
+    validate_cast_bounds_contained_same_min::<u8, u64>('u8 u64 casts');
+    validate_cast_bounds_contained_same_min::<u8, u128>('u8 u128 casts');
+    validate_cast_bounds_contained_same_min::<u16, u32>('u16 u32 casts');
+    validate_cast_bounds_contained_same_min::<u16, u64>('u16 u64 casts');
+    validate_cast_bounds_contained_same_min::<u16, u128>('u16 u128 casts');
+    validate_cast_bounds_contained_same_min::<u32, u64>('u32 u64 casts');
+    validate_cast_bounds_contained_same_min::<u32, u128>('u32 u128 casts');
+    validate_cast_bounds_contained_same_min::<u64, u128>('u64 u128 casts');
+
+    validate_cast_bounds_strictly_contained::<u8, i16>('u8 i16 casts');
+    validate_cast_bounds_strictly_contained::<u8, i32>('u8 i32 casts');
+    validate_cast_bounds_strictly_contained::<u8, i64>('u8 i64 casts');
+    validate_cast_bounds_strictly_contained::<u8, i128>('u8 i128 casts');
+    validate_cast_bounds_strictly_contained::<u16, i32>('u16 i32 casts');
+    validate_cast_bounds_strictly_contained::<u16, i64>('u16 i64 casts');
+    validate_cast_bounds_strictly_contained::<u16, i128>('u16 i128 casts');
+    validate_cast_bounds_strictly_contained::<u32, i64>('u32 i64 casts');
+    validate_cast_bounds_strictly_contained::<u32, i128>('u32 i128 casts');
+    validate_cast_bounds_strictly_contained::<u64, i128>('u64 i128 casts');
+
+    validate_cast_bounds_strictly_contained::<i8, i16>('i8 i16 casts');
+    validate_cast_bounds_strictly_contained::<i8, i32>('i8 i32 casts');
+    validate_cast_bounds_strictly_contained::<i8, i64>('i8 i64 casts');
+    validate_cast_bounds_strictly_contained::<i8, i128>('i8 i128 casts');
+    validate_cast_bounds_strictly_contained::<i16, i32>('i16 i32 casts');
+    validate_cast_bounds_strictly_contained::<i16, i64>('i16 i64 casts');
+    validate_cast_bounds_strictly_contained::<i16, i128>('i16 i128 casts');
+    validate_cast_bounds_strictly_contained::<i32, i64>('i32 i64 casts');
+    validate_cast_bounds_strictly_contained::<i32, i128>('i32 i128 casts');
+    validate_cast_bounds_strictly_contained::<i64, i128>('i64 i128 casts');
+
+    validate_cast_bounds_overlapping::<i8, u8>('i8 u8 casts');
+    validate_cast_bounds_overlapping::<i8, u16>('i8 u16 casts');
+    validate_cast_bounds_overlapping::<i8, u32>('i8 u32 casts');
+    validate_cast_bounds_overlapping::<i8, u64>('i8 u64 casts');
+    validate_cast_bounds_overlapping::<i8, u128>('i8 u128 casts');
+    validate_cast_bounds_overlapping::<i16, u16>('i16 u16 casts');
+    validate_cast_bounds_overlapping::<i16, u32>('i16 u32 casts');
+    validate_cast_bounds_overlapping::<i16, u64>('i16 u64 casts');
+    validate_cast_bounds_overlapping::<i16, u128>('i16 u128 casts');
+    validate_cast_bounds_overlapping::<i32, u32>('i32 u32 casts');
+    validate_cast_bounds_overlapping::<i32, u64>('i32 u64 casts');
+    validate_cast_bounds_overlapping::<i32, u128>('i32 u128 casts');
+    validate_cast_bounds_overlapping::<i64, u64>('i64 u64 casts');
+    validate_cast_bounds_overlapping::<i64, u128>('i64 u128 casts');
+    validate_cast_bounds_overlapping::<i128, u128>('i128 u128 casts');
 }
 
 #[test]
@@ -988,124 +1162,124 @@ fn test_into_self_type() {
 #[test]
 #[should_panic]
 fn panic_u16_u8_1() {
-    let out: u8 = (0xFF_u16 + 1_u16).try_into().unwrap();
+    let _out: u8 = (0xFF_u16 + 1_u16).try_into().unwrap();
 }
 
 #[test]
 #[should_panic]
 fn panic_u16_u8_2() {
     let max_u16: u16 = 0xFFFF;
-    let out: u8 = max_u16.try_into().unwrap();
+    let _out: u8 = max_u16.try_into().unwrap();
 }
 #[test]
 #[should_panic]
 fn panic_u32_u8_1() {
-    let out: u8 = (0xFF_u32 + 1_u32).try_into().unwrap();
+    let _out: u8 = (0xFF_u32 + 1_u32).try_into().unwrap();
 }
 
 #[test]
 #[should_panic]
 fn panic_u32_u8_2() {
     let max_u32: u32 = 0xFFFFFFFF;
-    let out: u8 = max_u32.try_into().unwrap();
+    let _out: u8 = max_u32.try_into().unwrap();
 }
 #[test]
 #[should_panic]
 fn panic_u64_u8_1() {
-    let out: u8 = (0xFF_u64 + 1_u64).try_into().unwrap();
+    let _out: u8 = (0xFF_u64 + 1_u64).try_into().unwrap();
 }
 
 #[test]
 #[should_panic]
 fn panic_u64_u8_2() {
     let max_u64: u64 = 0xFFFFFFFFFFFFFFFF;
-    let out: u8 = max_u64.try_into().unwrap();
+    let _out: u8 = max_u64.try_into().unwrap();
 }
 #[test]
 #[should_panic]
 fn panic_u128_u8_1() {
-    let out: u8 = (0xFF_u128 + 1_u128).try_into().unwrap();
+    let _out: u8 = (0xFF_u128 + 1_u128).try_into().unwrap();
 }
 
 #[test]
 #[should_panic]
 fn panic_u128_u8_2() {
     let max_u128: u128 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
-    let out: u8 = max_u128.try_into().unwrap();
+    let _out: u8 = max_u128.try_into().unwrap();
 }
 #[test]
 #[should_panic]
 fn panic_u32_u16_1() {
-    let out: u16 = (0xFFFF_u32 + 1_u32).try_into().unwrap();
+    let _out: u16 = (0xFFFF_u32 + 1_u32).try_into().unwrap();
 }
 
 #[test]
 #[should_panic]
 fn panic_u32_u16_2() {
     let max_u32: u32 = 0xFFFFFFFF;
-    let out: u16 = max_u32.try_into().unwrap();
+    let _out: u16 = max_u32.try_into().unwrap();
 }
 #[test]
 #[should_panic]
 fn panic_u64_u16_1() {
-    let out: u16 = (0xFFFF_u64 + 1_u64).try_into().unwrap();
+    let _out: u16 = (0xFFFF_u64 + 1_u64).try_into().unwrap();
 }
 
 #[test]
 #[should_panic]
 fn panic_u64_u16_2() {
     let max_u64: u64 = 0xFFFFFFFFFFFFFFFF;
-    let out: u16 = max_u64.try_into().unwrap();
+    let _out: u16 = max_u64.try_into().unwrap();
 }
 #[test]
 #[should_panic]
 fn panic_u128_u16_1() {
-    let out: u16 = (0xFFFF_u128 + 1_u128).try_into().unwrap();
+    let _out: u16 = (0xFFFF_u128 + 1_u128).try_into().unwrap();
 }
 
 #[test]
 #[should_panic]
 fn panic_u128_u16_2() {
     let max_u128: u128 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
-    let out: u16 = max_u128.try_into().unwrap();
+    let _out: u16 = max_u128.try_into().unwrap();
 }
 #[test]
 #[should_panic]
 fn panic_u64_u32_1() {
-    let out: u32 = (0xFFFFFFFF_u64 + 1_u64).try_into().unwrap();
+    let _out: u32 = (0xFFFFFFFF_u64 + 1_u64).try_into().unwrap();
 }
 
 #[test]
 #[should_panic]
 fn panic_u64_u32_2() {
     let max_u64: u64 = 0xFFFFFFFFFFFFFFFF;
-    let out: u32 = max_u64.try_into().unwrap();
+    let _out: u32 = max_u64.try_into().unwrap();
 }
 
 #[test]
 #[should_panic]
 fn panic_u128_u32_1() {
-    let out: u32 = (0xFFFFFFFF_u128 + 1_u128).try_into().unwrap();
+    let _out: u32 = (0xFFFFFFFF_u128 + 1_u128).try_into().unwrap();
 }
 
 #[test]
 #[should_panic]
 fn panic_u128_u32_2() {
     let max_u128: u128 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
-    let out: u32 = max_u128.try_into().unwrap();
+    let _out: u32 = max_u128.try_into().unwrap();
 }
 
 #[test]
 #[should_panic]
 fn panic_u128_u64_1() {
-    let out: u64 = (0xFFFFFFFFFFFFFFFF_u128 + 1_u128).try_into().unwrap();
+    let _out: u64 = (0xFFFFFFFFFFFFFFFF_u128 + 1_u128).try_into().unwrap();
 }
 
 #[test]
 #[should_panic]
 fn panic_u128_u64_2() {
     let max_u128: u128 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
-    let out: u64 = max_u128.try_into().unwrap();
+    let _out: u64 = max_u128.try_into().unwrap();
 }
 
 #[test]
@@ -1563,6 +1737,20 @@ fn test_i128_operators() {
     assert_eq(@(-3_i128 + -6_i128), @-9_i128, '-3 + -6 == -9');
     assert_eq(@(-3_i128 - -1_i128), @-2_i128, '-3 - -1 == -2');
     assert_eq(@(-231_i128 - -131_i128), @-100_i128, '-231--131=-100');
+    assert_eq(@(1_i128 * 3_i128), @3_i128, '1 * 3 == 3');
+    assert_eq(@(7_i128 * 0_i128), @0_i128, '7 * 0 == 0');
+    assert_eq(@(2_i128 * 4_i128), @8_i128, '2 * 4 == 8');
+    assert_eq(@(-1_i128 * 3_i128), @-3_i128, '-1 * 3 == -3');
+    assert_eq(@(-2_i128 * 4_i128), @-8_i128, '-2 * 4 == -8');
+    assert_eq(@(1_i128 * -3_i128), @-3_i128, '1 * -3 == -3');
+    assert_eq(@(2_i128 * -4_i128), @-8_i128, '2 * -4 == -8');
+    assert_eq(@(-1_i128 * -3_i128), @3_i128, '-1 * -3 == 3');
+    assert_eq(@(-2_i128 * -4_i128), @8_i128, '-2 * -4 == 8');
+    assert_eq(
+        @(0x800000000000000_i128 * -0x100000000000000000_i128),
+        @-0x80000000000000000000000000000000_i128,
+        'failed MIN_I128 as mul result'
+    );
     assert_lt(1_i128, 4_i128, '1 < 4');
     assert_le(1_i128, 4_i128, '1 <= 4');
     assert(!(4_i128 < 4_i128), '!(4 < 4)');
@@ -1622,6 +1810,24 @@ fn test_i128_add_underflow() {
     -0x64000000000000000000000000000000_i128 + -0x1e000000000000000000000000000000_i128;
 }
 
+#[test]
+#[should_panic]
+fn test_i128_mul_overflow_1() {
+    0x10000000000000000000000000000000_i128 * 0x10000000000000000000000000000000_i128;
+}
+
+#[test]
+#[should_panic]
+fn test_i128_mul_overflow_2() {
+    0x11000000000000000000000000000000_i128 * 0x10000000000000000000000000000000_i128;
+}
+
+#[test]
+#[should_panic]
+fn test_i128_mul_overflow_3() {
+    2_i128 * 0x40000000000000000000000000000000_i128;
+}
+
 #[test]
 fn test_signed_int_diff() {
     assert_eq(@integer::i8_diff(3, 3).unwrap(), @0, 'i8: 3 - 3 == 0');
diff --git a/corelib/src/test/keccak_test.cairo b/corelib/src/test/keccak_test.cairo
index ad4a368..6c9c6c0 100644
--- a/corelib/src/test/keccak_test.cairo
+++ b/corelib/src/test/keccak_test.cairo
@@ -1,8 +1,7 @@
 use starknet::SyscallResultTrait;
-use test::test_utils::{assert_eq, assert_ne};
+use core::test::test_utils::{assert_eq, assert_ne};
 
 #[test]
-#[available_gas(10000000)]
 fn test_keccak_syscall() {
     let input = array![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17];
     assert_eq(
@@ -13,7 +12,6 @@ fn test_keccak_syscall() {
 }
 
 #[test]
-#[available_gas(10000000)]
 fn test_keccak_hash() {
     let res = keccak::keccak_u256s_le_inputs(array![1].span());
     assert_eq(@res.low, @0x587f7cc3722e9654ea3963d5fe8c0748, 'Wrong hash low 1');
@@ -34,7 +32,6 @@ fn test_keccak_hash() {
 
 // Same input as in `test_keccak_hash` but as a u64 array.
 #[test]
-#[available_gas(10000000)]
 fn test_keccak_u64() {
     let mut input = array![
         0x0000000000000001, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000
@@ -47,7 +44,6 @@ fn test_keccak_u64() {
 }
 
 #[test]
-#[available_gas(10000000)]
 fn test_keccak_u64_full_block() {
     let mut input = array![
         0x0000000000000001,
@@ -76,7 +72,6 @@ fn test_keccak_u64_full_block() {
 }
 
 #[test]
-#[available_gas(10000000)]
 fn test_keccak_u64_full_block_minus_byte() {
     let mut input = array![
         0x0000000000000001,
@@ -113,7 +108,6 @@ fn test_keccak_u64_full_block_minus_byte() {
 }
 
 #[test]
-#[available_gas(10000000)]
 fn test_keccak_u64_full_block_minus_word() {
     let mut input = array![
         0x0000000000000001,
@@ -141,7 +135,6 @@ fn test_keccak_u64_full_block_minus_word() {
 }
 
 #[test]
-#[available_gas(10000000)]
 fn test_keccak_u64_full_block_minus_word_minus_byte() {
     let mut input = array![
         0x0000000000000001,
@@ -177,7 +170,6 @@ fn test_keccak_u64_full_block_minus_word_minus_byte() {
 }
 
 #[test]
-#[available_gas(10000000)]
 fn test_keccak_u64_full_block_minus_3_words_minus_4_bytes() {
     let mut input = array![
         0x0000000000000001,
diff --git a/corelib/src/test/math_test.cairo b/corelib/src/test/math_test.cairo
index ef33428..bfe492a 100644
--- a/corelib/src/test/math_test.cairo
+++ b/corelib/src/test/math_test.cairo
@@ -1,43 +1,42 @@
+use core::option::OptionTrait;
+use core::math;
+
+/// Helper for making a non-zero value.
+fn nz<N, +TryInto<N, NonZero<N>>>(n: N) -> NonZero<N> {
+    n.try_into().unwrap()
+}
+
 #[test]
-#[available_gas(10000000)]
 fn test_egcd() {
-    let (g, s, t, sub_direction) = math::egcd(68_u8.try_into().unwrap(), 16_u8.try_into().unwrap());
+    let (g, s, t, sub_direction) = math::egcd(nz(68_u8), nz(16_u8));
     assert(g == 4, 'g != 4');
     assert(s == 1, 's != 1');
     assert(t == 4, 't != 4');
     assert(sub_direction, 'sub_direction is wrong');
     assert(1 * 68 - 4 * 16 == 4, 'Sanity check failed');
 
-    let (g, s, t, sub_direction) = math::egcd(
-        240_u256.try_into().unwrap(), 46_u256.try_into().unwrap()
-    );
+    let (g, s, t, sub_direction) = math::egcd(nz(240_u256), nz(46_u256));
     assert(g == 2, 'g != 2');
     assert(s == 9, 's != 9');
     assert(t == 47, 't != 47');
     assert(!sub_direction, 'sub_direction is wrong');
     assert(47 * 46 - 9 * 240 == 2, 'Sanity check failed');
 
-    let (g, s, t, sub_direction) = math::egcd(
-        50_u128.try_into().unwrap(), 17_u128.try_into().unwrap()
-    );
+    let (g, s, t, sub_direction) = math::egcd(nz(50_u128), nz(17_u128));
     assert(g == 1, 'g != 1');
     assert(s == 1, 's != 1');
     assert(t == 3, 't != 3');
     assert(!sub_direction, 'sub_direction is wrong');
     assert(3 * 17 - 1 * 50 == 1, 'Sanity check failed');
 
-    let (g, s, t, sub_direction) = math::egcd(
-        5_u128.try_into().unwrap(), 15_u128.try_into().unwrap()
-    );
+    let (g, s, t, sub_direction) = math::egcd(nz(5_u128), nz(15_u128));
     assert(g == 5, 'g != 5');
     assert(s == 1, 's != 1');
     assert(t == 0, 't != 0');
     assert(sub_direction, 'sub_direction is wrong');
     assert(1 * 5 - 0 * 15 == 5, 'Sanity check failed');
 
-    let (g, s, t, sub_direction) = math::egcd(
-        1_u128.try_into().unwrap(), 1_u128.try_into().unwrap()
-    );
+    let (g, s, t, sub_direction) = math::egcd(nz(1_u128), nz(1_u128));
     assert(g == 1, 'g != 1');
     assert(s == 0, 's != 0');
     assert(t == 1, 't != 1');
@@ -46,50 +45,82 @@ fn test_egcd() {
 }
 
 #[test]
-#[available_gas(10000000)]
 fn test_inv_mod() {
-    let inv = math::inv_mod(5_u256.try_into().unwrap(), 24_u256.try_into().unwrap()).unwrap();
-    assert(inv == 5, 'inv != 5');
-
-    let inv = math::inv_mod(29_u128.try_into().unwrap(), 24_u128.try_into().unwrap()).unwrap();
-    assert(inv == 5, 'inv != 5');
-
-    let inv = math::inv_mod(1_u16.try_into().unwrap(), 24_u16.try_into().unwrap()).unwrap();
-    assert(inv == 1, 'inv != 1');
-
-    let inv = math::inv_mod(1_u32.try_into().unwrap(), 5_u32.try_into().unwrap()).unwrap();
-    assert(inv == 1, 'inv != 1');
-
-    let inv = math::inv_mod(8_usize.try_into().unwrap(), 24_usize.try_into().unwrap());
-    assert(inv.is_none(), 'inv should be None');
-
-    let inv = math::inv_mod(1_usize.try_into().unwrap(), 1_usize.try_into().unwrap()).unwrap();
-    assert(inv == 0, 'inv != 0');
-
-    let inv = math::inv_mod(7_usize.try_into().unwrap(), 1_usize.try_into().unwrap()).unwrap();
-    assert(inv == 0, 'inv != 0');
+    assert(math::inv_mod(nz(5), nz(24)) == Option::Some(5_u256), 'inv_mov(5, 24) != 5');
+    assert(math::inv_mod(nz(29), nz(24)) == Option::Some(5_u128), 'inv_mov(29, 24) != 5');
+    assert(math::inv_mod(nz(1), nz(24)) == Option::Some(1_u16), 'inv_mov(1, 24) != 1');
+    assert(math::inv_mod(nz(1), nz(5)) == Option::Some(1_u32), 'inv_mov(1, 5) != 1');
+    assert(math::inv_mod(nz(8_usize), nz(24_usize)).is_none(), 'inv_mov(8, 24) != None');
+    assert(math::inv_mod(nz(1), nz(1)) == Option::Some(0_usize), 'inv_mov(1, 1) != 0');
+    assert(math::inv_mod(nz(7), nz(1)) == Option::Some(0_usize), 'inv_mov(7, 1) != 0');
 }
 
 #[test]
-#[available_gas(10000000)]
 fn test_u256_div_mod_n() {
-    let q = math::u256_div_mod_n(6_u256, 2_u256.try_into().unwrap(), 7_u256.try_into().unwrap())
-        .unwrap();
-    assert(q == 3, '6 / 2 != 3 (7)');
-
-    let q = math::u256_div_mod_n(5_u256, 1_u256.try_into().unwrap(), 7_u256.try_into().unwrap())
-        .unwrap();
-    assert(q == 5, '5 / 1 != 5 (7)');
-
-    let q = math::u256_div_mod_n(1_u256, 1_u256.try_into().unwrap(), 7_u256.try_into().unwrap())
-        .unwrap();
-    assert(q == 1, '1 / 1 != 1 (7)');
-
-    let q = math::u256_div_mod_n(7_u256, 2_u256.try_into().unwrap(), 13_u256.try_into().unwrap())
-        .unwrap();
-    assert(q == 10, '7 / 2 != 10 (13)');
+    assert(math::u256_div_mod_n(6, 2, nz(7)) == Option::Some(3), '6 / 2 != 3 (7)');
+    assert(math::u256_div_mod_n(5, 1, nz(7)) == Option::Some(5), '5 / 1 != 5 (7)');
+    assert(math::u256_div_mod_n(1, 1, nz(7)) == Option::Some(1), '1 / 1 != 1 (7)');
+    assert(math::u256_div_mod_n(7, 2, nz(13)) == Option::Some(10), '7 / 2 != 10 (13)');
+    assert(math::u256_div_mod_n(0, 3, nz(13)) == Option::Some(0), '0 / 3 != 0 (13)');
+    assert(math::u256_div_mod_n(4, 3, nz(6)).is_none(), '4 / 3 == None (6)');
+    assert(math::u256_div_mod_n(5, 4, nz(6)).is_none(), '5 / 4 == None (6)');
+    assert(math::u256_div_mod_n(2, 8, nz(4)).is_none(), '2 / 8 == None (4)');
+    assert(
+        math::u256_div_mod_n(
+            0xfa855081cc80656250605b2ecd7958ba4f0aa6799053da0d68bf76f2484decc6,
+            0xe8e94a59a951af1b4c8cbd45fb8d01c1dd946de2533e3ad18845f9dbb6d12f4f,
+            nz(0xa3db605888ac3cd19e70c5b52220ad693566b996ef078e907578fec7758dabc9)
+        ) == Option::Some(0x8e70aea916ee4b782a0da9c18083ed9d867148a703615a2a88d0e7fddd4c900d),
+        'Random large values 1'
+    );
+    assert(
+        math::u256_div_mod_n(
+            0x759426f1c0ba213b6378196b5091f5fa48f49f1d0cecfb00a7d59a51be35f609,
+            0x57ff2c2e0900fce82331e396a71787a837783cca8145538eb32cb4b52104a3be,
+            nz(0xcb514e4d4672d8f1d952c0312afb5baae86121aa5817030d8439ce759295a029)
+        ) == Option::Some(0x7c9d22b40f98075c0bfd674d546bc77d775dcf021d30b88afb099834dffa951b),
+        'Random large values 2'
+    );
+}
 
-    let q = math::u256_div_mod_n(0_u256, 3_u256.try_into().unwrap(), 13_u256.try_into().unwrap())
-        .unwrap();
-    assert(q == 0, '0 / 3 != 0 (13)');
+#[test]
+fn test_u256_inv_mod() {
+    assert(math::u256_inv_mod(5, nz(24)).unwrap().into() == 5_u256, 'inv_mov(5, 24) != 5');
+    assert(math::u256_inv_mod(29, nz(24)).unwrap().into() == 5_u256, 'inv_mov(29, 24) != 5');
+    assert(math::u256_inv_mod(1, nz(24)).unwrap().into() == 1_u256, 'inv_mov(1, 24) != 1');
+    assert(math::u256_inv_mod(1, nz(5)).unwrap().into() == 1_u256, 'inv_mov(1, 5) != 1');
+    assert(math::u256_inv_mod(8, nz(24)).is_none(), 'inv_mov(8, 24) != None');
+    assert(math::u256_inv_mod(1, nz(1)).is_none(), 'inv_mov(1, 1) != None');
+    assert(math::u256_inv_mod(7, nz(1)).is_none(), 'inv_mov(7, 1) != None');
+    assert(math::u256_inv_mod(0, nz(1)).is_none(), 'inv_mov(0, 1) != None');
+    assert(math::u256_inv_mod(0, nz(7)).is_none(), 'inv_mov(0, 7) != None');
+    assert(math::u256_inv_mod(3, nz(6)).is_none(), 'inv_mod(3, 6) != None');
+    assert(math::u256_inv_mod(4, nz(6)).is_none(), 'inv_mod(4, 6) != None');
+    assert(math::u256_inv_mod(8, nz(4)).is_none(), 'inv_mod(8, 4) != None');
+    assert(
+        math::u256_inv_mod(
+            0xea9195982bd472e30e5146ad7cb0acd954cbc75032a298ac73234b6b05e28cc1,
+            nz(0x4075f980fab77a3fde536dbaae600f5ea1540e01837dcec64c1f379613aa4d18)
+        )
+            .is_none(),
+        'Random 1'
+    );
+    assert(
+        math::u256_inv_mod(
+            0x85ef555d7a0aa34019c138defc40a1d3683dc1caa505bff286dd8069a28a2e4c,
+            nz(0xd71e5a5f4a4d1af45e703f9e13d1305ce149313037956247ad5edfe3e81d6353)
+        )
+            .is_none(),
+        'Random 2'
+    );
+    let large_gcd = 0x63f7a7326f84cfca7738923db2b6d6c1b1b;
+    assert(
+        math::u256_inv_mod(
+            large_gcd * 0x51e28b744cc00edfb6bbbe6a9, nz(large_gcd * 0xc09497df4aa02be7fd25f10d3)
+        )
+            .is_none(),
+        'gcd ~ 2**140'
+    );
+    let very_large_gcd = 0x74c5ef92be07ee4ad43ae8ca337390e4a5dfdbf4f1a5f09cdf412ab7ce343503;
+    assert(math::u256_inv_mod(very_large_gcd, nz(very_large_gcd)).is_none(), 'gcd ~ 2**256');
 }
diff --git a/corelib/src/test/nullable_test.cairo b/corelib/src/test/nullable_test.cairo
new file mode 100644
index 0000000..22c0fbc
--- /dev/null
+++ b/corelib/src/test/nullable_test.cairo
@@ -0,0 +1,31 @@
+use core::test::test_utils::{assert_eq, assert_ne};
+use core::nullable::null;
+
+#[test]
+fn test_nullable_felt252s() {
+    let x = 10;
+    let nullable_x = NullableTrait::new(x);
+    assert(!nullable_x.is_null(), 'nullable_x.is_null() true');
+    assert_eq(@nullable_x.deref(), @x, '*&x != x');
+    let y = 11;
+    let nullable_y = NullableTrait::new(y);
+    assert(!nullable_y.is_null(), 'nullable_y.is_null() true');
+    assert_eq(@nullable_y.deref(), @y, '*&y != y');
+    let null: Nullable<felt252> = null();
+    assert(null.is_null(), 'null.is_null() false');
+}
+
+// Testing `u256` as a test for objects of size larger than 1.
+#[test]
+fn test_nullable_u256() {
+    let x: u256 = 10;
+    let nullable_x = NullableTrait::new(x);
+    assert(!nullable_x.is_null(), 'nullable_x.is_null() true');
+    assert_eq(@nullable_x.deref(), @x, '*&x != x');
+    let y: u256 = 11;
+    let nullable_y = NullableTrait::new(y);
+    assert(!nullable_y.is_null(), 'nullable_y.is_null() true');
+    assert_eq(@nullable_y.deref(), @y, '*&y != y');
+    let null: Nullable<u256> = null();
+    assert(null.is_null(), 'null.is_null() false');
+}
diff --git a/corelib/src/test/num_test.cairo b/corelib/src/test/num_test.cairo
new file mode 100644
index 0000000..bdd4357
--- /dev/null
+++ b/corelib/src/test/num_test.cairo
@@ -0,0 +1,17 @@
+use core::num::traits::BitSize;
+
+#[test]
+fn test_bit_size() {
+    assert!(BitSize::<u8>::bits() == 8);
+    assert!(BitSize::<u16>::bits() == 16);
+    assert!(BitSize::<u32>::bits() == 32);
+    assert!(BitSize::<u64>::bits() == 64);
+    assert!(BitSize::<u128>::bits() == 128);
+    assert!(BitSize::<u256>::bits() == 256);
+    assert!(BitSize::<i8>::bits() == 8);
+    assert!(BitSize::<i16>::bits() == 16);
+    assert!(BitSize::<i32>::bits() == 32);
+    assert!(BitSize::<i64>::bits() == 64);
+    assert!(BitSize::<i128>::bits() == 128);
+    assert!(BitSize::<bytes31>::bits() == 248);
+}
diff --git a/corelib/src/test/panics_test.cairo b/corelib/src/test/panics_test.cairo
new file mode 100644
index 0000000..5115fd3
--- /dev/null
+++ b/corelib/src/test/panics_test.cairo
@@ -0,0 +1,146 @@
+use core::byte_array::BYTE_ARRAY_MAGIC;
+use core::{panics, panic_with_felt252};
+
+#[test]
+#[should_panic(expected: 'short_string')]
+fn test_panic_with_short_string() {
+    panic_with_felt252('short_string');
+}
+
+#[test]
+#[should_panic(expected: 1)]
+fn test_panic_with_felt252() {
+    panic_with_felt252(1);
+}
+
+#[test]
+#[should_panic(expected: "")]
+fn test_panic_with_byte_array_empty() {
+    let ba: ByteArray = Default::default();
+    panics::panic_with_byte_array(@ba);
+}
+
+#[test]
+#[should_panic(expected: "error")]
+fn test_panic_with_byte_array_short() {
+    let ba: ByteArray = "error";
+    panics::panic_with_byte_array(@ba);
+}
+
+#[test]
+#[should_panic(expected: "long error with more than 31 characters")]
+fn test_panic_with_byte_array_long() {
+    let ba: ByteArray = "long error with more than 31 characters";
+    panics::panic_with_byte_array(@ba);
+}
+
+#[test]
+#[should_panic(expected: "long err\0r with more than 31 characters")]
+fn test_panic_with_byte_array_null_in_full_word() {
+    let mut ba: ByteArray = "long err";
+    ba.append_byte(0);
+    let ba2: ByteArray = "r with more than 31 characters";
+    ba.append(@ba2);
+    panics::panic_with_byte_array(@ba);
+}
+
+#[test]
+#[should_panic(expected: "long error with more than 31 character\0s")]
+fn test_panic_with_byte_array_null_in_pending() {
+    let mut ba: ByteArray = "long error with more than 31 character";
+    ba.append_byte(0);
+    let ba2: ByteArray = "s";
+    ba.append(@ba2);
+    panics::panic_with_byte_array(@ba);
+}
+
+#[test]
+#[should_panic(expected: "\0error")]
+fn test_panic_with_byte_array_null_in_beginning() {
+    let mut ba: ByteArray = "";
+    ba.append_byte(0);
+    let ba2: ByteArray = "error";
+    ba.append(@ba2);
+    panics::panic_with_byte_array(@ba);
+}
+
+#[test]
+#[should_panic(expected: ("error", 11, "hello", 5, 'short_string'))]
+fn test_panic_with_stacked_errors() {
+    let mut error = array![];
+    let ba: ByteArray = "error";
+    error.append(BYTE_ARRAY_MAGIC);
+    ba.serialize(ref error);
+
+    error.append(11);
+
+    let ba: ByteArray = "hello";
+    error.append(BYTE_ARRAY_MAGIC);
+    ba.serialize(ref error);
+
+    error.append(5);
+    error.append('short_string');
+
+    panic(error);
+}
+
+#[test]
+#[should_panic(
+    expected: (
+        0x46a6158a16a947e5916b2a2ca68501a45e93d7110e81aa2d6438b1c57c879a3, // BYTE_ARRAY_MAGIC
+        1,
+        0x161616161616161616161616161616161616161616161616161616161616161,
+        0,
+        0
+    )
+)]
+fn test_panic_with_byte_array_invalid_full_word() {
+    // This is a serialized ByteArray, but the full word is an invalid short string (> 2^248).
+    let mut error = array![
+        BYTE_ARRAY_MAGIC,
+        1, // A single full word.
+        0x161616161616161616161616161616161616161616161616161616161616161, // The invalid full word.
+        0,
+        0 // pending byte is empty.
+    ];
+    panic(error);
+}
+
+#[test]
+#[should_panic(
+    expected: (
+        0x46a6158a16a947e5916b2a2ca68501a45e93d7110e81aa2d6438b1c57c879a3, // BYTE_ARRAY_MAGIC
+        0,
+        'aa',
+        1
+    )
+)]
+fn test_panic_with_byte_array_invalid_pending_word() {
+    // This is a serialized ByteArray, but the pending word length < the actual data in the pending
+    // word.
+    let mut error = array![
+        BYTE_ARRAY_MAGIC,
+        0, // No full words.
+        'aa',
+        1 // pending word length. Smaller than the actual data in the pending word.
+    ];
+    panic(error);
+}
+
+#[test]
+#[should_panic(expected: "")]
+fn test_panic_macro_empty() {
+    panic!()
+}
+
+#[test]
+#[should_panic(expected: "basic")]
+fn test_panic_macro_basic_string() {
+    panic!("basic")
+}
+
+#[test]
+#[should_panic(expected: "some_format(1)")]
+fn test_panic_macro_with_input() {
+    panic!("some_format({})", 1)
+}
diff --git a/corelib/src/test/plugins_test.cairo b/corelib/src/test/plugins_test.cairo
index 332a5cd..a44f619 100644
--- a/corelib/src/test/plugins_test.cairo
+++ b/corelib/src/test/plugins_test.cairo
@@ -1,20 +1,20 @@
-use test::test_utils::{assert_eq, assert_ne};
+use core::test::test_utils::assert_eq;
 
-#[derive(Copy, Drop, Serde, PartialEq)]
+#[derive(Copy, Debug, Drop, Serde, PartialEq)]
 enum EnumForSerde {
     A,
     B: u32,
     C: u64,
 }
 
-#[derive(Drop, Default, PartialEq)]
+#[derive(Drop, Debug, Default, PartialEq)]
 struct StructForDefault {
     a: felt252,
     b: u256,
     c: bool
 }
 
-#[derive(Drop, Default, PartialEq)]
+#[derive(Drop, Debug, Default, PartialEq)]
 enum EnumForDefault {
     A: felt252,
     B: u256,
@@ -24,7 +24,7 @@ enum EnumForDefault {
 
 #[test]
 fn test_derive_serde_enum() {
-    let a = EnumForSerde::A(());
+    let a = EnumForSerde::A;
     let b = EnumForSerde::B(1);
     let c = EnumForSerde::C(2);
     let mut output = Default::default();
@@ -64,14 +64,10 @@ fn test_derive_serde_enum() {
 
 #[test]
 fn test_derive_default_struct() {
-    let actual: StructForDefault = Default::default();
-    let expected = StructForDefault { a: 0, b: 0, c: bool::False };
-    assert_eq(@actual, @expected, 'unexpected default value');
+    assert_eq!(Default::default(), StructForDefault { a: 0, b: 0, c: false });
 }
 
 #[test]
 fn test_derive_default_enum() {
-    let actual: EnumForDefault = Default::default();
-    let expected = EnumForDefault::C(StructForDefault { a: 0, b: 0, c: bool::False });
-    assert_eq(@actual, @expected, 'unexpected default value');
+    assert_eq!(Default::default(), EnumForDefault::C(StructForDefault { a: 0, b: 0, c: false }));
 }
diff --git a/corelib/src/test/print_test.cairo b/corelib/src/test/print_test.cairo
new file mode 100644
index 0000000..161d10a
--- /dev/null
+++ b/corelib/src/test/print_test.cairo
@@ -0,0 +1,131 @@
+use core::byte_array::BYTE_ARRAY_MAGIC;
+use core::debug::{PrintTrait, print_byte_array_as_string};
+
+#[ignore]
+#[test]
+fn test_prints() {
+    // Valid short string.
+    'hello'.print();
+
+    // felt252
+    1.print();
+
+    // Valid string with < 31 characters (no full words).
+    let x: ByteArray = "short, but string";
+    print_byte_array_as_string(@x);
+
+    // Valid string with > 31 characters (with a full word).
+    let x: ByteArray = "This is a long string with more than 31 characters.";
+    print_byte_array_as_string(@x);
+
+    // Valid string as an array.
+    let x = array![
+        BYTE_ARRAY_MAGIC,
+        1, // A single full word.
+        'This is a long string with more',
+        ' than 31 characters.',
+        20 // pending word length. Bigger than the actual data in the pending word.
+    ];
+    x.print();
+
+    // Only magic.
+    let x = array![BYTE_ARRAY_MAGIC];
+    x.print();
+
+    // num_full_words > usize.
+    let x = array![BYTE_ARRAY_MAGIC, 0x100000000];
+    x.print();
+
+    // Not enough data after num_full_words.
+    let x = array![BYTE_ARRAY_MAGIC, 0];
+    x.print();
+
+    // Not enough full words.
+    let x = array![BYTE_ARRAY_MAGIC, 1, 0, 0];
+    x.print();
+
+    // Too much data in full word.
+    let x = array![
+        BYTE_ARRAY_MAGIC,
+        1, // A single full word.
+        0x161616161616161616161616161616161616161616161616161616161616161, // The invalid full word.
+        0,
+        0 // pending byte is empty.
+    ];
+    x.print();
+
+    // num_pending_bytes > usize.
+    let x = array![BYTE_ARRAY_MAGIC, 0, 0, 0x100000000];
+    x.print();
+
+    // "Not enough" data in pending_word (nulls in the beginning).
+    let x = array![
+        BYTE_ARRAY_MAGIC,
+        0, // No full words.
+        'a',
+        2 // pending word length. Bigger than the actual data in the pending word.
+    ];
+    x.print();
+
+    // Too much data in pending_word.
+    let x = array![
+        BYTE_ARRAY_MAGIC,
+        0, // No full words.
+        'aa',
+        1 // pending word length. Smaller than the actual data in the pending word.
+    ];
+    x.print();
+
+    // Valid string with Null.
+    let mut x: ByteArray = "Hello";
+    x.append_byte(0); // '\0'
+    let suffix: ByteArray = "world";
+    x.append(@suffix);
+    print_byte_array_as_string(@x);
+
+    // Valid string with a non printable character.
+    let mut x: ByteArray = "Hello";
+    x.append_byte(0x11); // Non printable character.
+    let suffix: ByteArray = "world";
+    x.append(@suffix);
+    print_byte_array_as_string(@x);
+
+    // Valid string with a newline.
+    let mut x: ByteArray = "Hello";
+    x.append_byte(0xA); // '\n'
+    let suffix: ByteArray = "world";
+    x.append(@suffix);
+    print_byte_array_as_string(@x);
+
+    // Multiple values: (felt, string, short_string, felt)
+    let x = array![0x9999, BYTE_ARRAY_MAGIC, 0, 'hello', 5, 'world', 0x8888];
+    x.print();
+}
+
+#[ignore]
+#[test]
+fn test_print_macro() {
+    // With a ByteArray.
+    let ba: ByteArray = "hello";
+    print!("{}", ba);
+
+    // With a felt252.
+    print!("{}", 97_felt252);
+
+    // With an integer.
+    print!("{}", 97_usize);
+}
+
+#[ignore]
+#[test]
+fn test_println_macro() {
+    // With a ByteArray.
+    let ba: ByteArray = "hello";
+    println!("{}", ba);
+
+    // With a felt252.
+    println!("{}", 97_felt252);
+
+    // With an integer.
+    println!("{}", 97_usize);
+}
diff --git a/corelib/src/test/result_test.cairo b/corelib/src/test/result_test.cairo
new file mode 100644
index 0000000..4d4fa83
--- /dev/null
+++ b/corelib/src/test/result_test.cairo
@@ -0,0 +1,125 @@
+use core::result::{Result, ResultTraitImpl};
+
+#[test]
+fn test_result_ok_expect() {
+    let result: Result<u32, felt252> = Result::Ok(42);
+    assert(result.expect('') == 42, 'result_ok_expect');
+}
+
+#[test]
+#[should_panic(expected: ('err msg',))]
+fn test_result_err_expect() {
+    let result: Result<u32, felt252> = Result::Err('no');
+    result.expect('err msg');
+}
+
+#[test]
+fn test_result_ok_unwrap() {
+    let result: Result<u32, felt252> = Result::Ok(42);
+    assert(result.unwrap() == 42, 'result_ok_unwrap');
+}
+
+#[test]
+#[should_panic(expected: ('Result::unwrap failed.',))]
+fn test_result_err_unwrap() {
+    let result: Result<u32, felt252> = Result::Err('no');
+    result.unwrap();
+}
+
+#[test]
+fn test_result_ok_unwrap_or() {
+    let result: Result<u32, felt252> = Result::Ok(42);
+    assert(result.unwrap_or(0) == 42, 'result_ok_unwrap_or');
+}
+
+#[test]
+fn test_result_err_unwrap_or() {
+    let result: Result<u32, felt252> = Result::Err('no');
+    assert(result.unwrap_or(0) == 0, 'result_err_unwrap_or');
+}
+
+#[test]
+fn test_result_ok_unwrap_or_default() {
+    let result: Result<u32, felt252> = Result::Ok(42);
+    assert(result.unwrap_or_default() == 42, 'result_ok_unwrap_or_default');
+}
+
+#[test]
+fn test_result_err_unwrap_or_default() {
+    let result: Result<u32, felt252> = Result::Err('no');
+    assert(result.unwrap_or_default() == 0, 'result_err_unwrap_or_default');
+}
+
+#[test]
+#[should_panic(expected: ('err msg',))]
+fn test_result_ok_expect_err() {
+    let result: Result<u32, felt252> = Result::Ok(42);
+    result.expect_err('err msg');
+}
+
+#[test]
+fn test_result_err_expect_err() {
+    let result: Result<u32, felt252> = Result::Err('no');
+    assert(result.expect_err('') == 'no', 'result_err_expect_err');
+}
+
+#[test]
+#[should_panic(expected: ('Result::unwrap_err failed.',))]
+fn test_result_ok_unwrap_err() {
+    let result: Result<u32, felt252> = Result::Ok(42);
+    result.unwrap_err();
+}
+
+#[test]
+fn test_result_err_unwrap_err() {
+    let result: Result<u32, felt252> = Result::Err('no');
+    assert(result.unwrap_err() == 'no', 'result_err_unwrap_err');
+}
+
+#[test]
+fn test_result_ok_is_ok() {
+    let result: Result<u32, felt252> = Result::Ok(42);
+    assert(result.is_ok(), 'result_ok_is_ok');
+}
+
+#[test]
+fn test_result_err_is_ok() {
+    let result: Result<u32, felt252> = Result::Err('no');
+    assert(!result.is_ok(), 'result_err_is_ok');
+}
+
+#[test]
+fn test_result_ok_is_err() {
+    let result: Result<u32, felt252> = Result::Ok(42);
+    assert(!result.is_err(), 'result_ok_is_err');
+}
+
+#[test]
+fn test_result_err_is_err() {
+    let result: Result<u32, felt252> = Result::Err('no');
+    assert(result.is_err(), 'result_err_is_err');
+}
+
+#[test]
+fn test_result_ok_into_is_err() {
+    let result: Result<u32, felt252> = Result::Ok(42);
+    assert(!result.into_is_err(), 'result_ok_into_is_err');
+}
+
+#[test]
+fn test_result_err_into_is_err() {
+    let result: Result<u32, felt252> = Result::Err('no');
+    assert(result.into_is_err(), 'result_err_into_is_err');
+}
+
+#[test]
+fn test_result_ok_into_is_ok() {
+    let result: Result<u32, felt252> = Result::Ok(42);
+    assert(result.into_is_ok(), 'result_ok_into_is_ok');
+}
+
+#[test]
+fn test_result_err_into_is_ok() {
+    let result: Result<u32, felt252> = Result::Err('no');
+    assert(!result.into_is_ok(), 'result_err_into_is_ok');
+}
diff --git a/corelib/src/test/secp256k1_test.cairo b/corelib/src/test/secp256k1_test.cairo
index 537cd9b..2fb253b 100644
--- a/corelib/src/test/secp256k1_test.cairo
+++ b/corelib/src/test/secp256k1_test.cairo
@@ -2,12 +2,12 @@ use starknet::{
     eth_address::U256IntoEthAddress, EthAddress, secp256k1::Secp256k1Impl, SyscallResultTrait
 };
 use starknet::secp256_trait::{
-    Signature, recover_public_key, verify_eth_signature, Secp256PointTrait, signature_from_vrs
+    Signature, recover_public_key, Secp256PointTrait, signature_from_vrs, is_valid_signature
 };
 use starknet::secp256k1::{Secp256k1Point, Secp256k1PointImpl};
+use starknet::eth_signature::verify_eth_signature;
 
 #[test]
-#[available_gas(100000000)]
 fn test_secp256k1_recover_public_key() {
     let y_parity = true;
     let (msg_hash, signature, expected_public_key_x, expected_public_key_y, _) =
@@ -63,51 +63,77 @@ fn get_message_and_signature(y_parity: bool) -> (u256, Signature, u256, u256, Et
 }
 
 #[test]
-#[available_gas(100000000)]
 fn test_verify_eth_signature() {
     let y_parity = true;
-    let (msg_hash, signature, expected_public_key_x, expected_public_key_y, eth_address) =
+    let (msg_hash, signature, _expected_public_key_x, _expected_public_key_y, eth_address) =
         get_message_and_signature(
         :y_parity
     );
-    verify_eth_signature::<Secp256k1Point>(:msg_hash, :signature, :eth_address);
+    verify_eth_signature(:msg_hash, :signature, :eth_address);
 }
 
 #[test]
 #[should_panic(expected: ('Invalid signature',))]
-#[available_gas(100000000)]
 fn test_verify_eth_signature_wrong_eth_address() {
     let y_parity = true;
-    let (msg_hash, signature, expected_public_key_x, expected_public_key_y, eth_address) =
+    let (msg_hash, signature, _expected_public_key_x, _expected_public_key_y, eth_address) =
         get_message_and_signature(
         :y_parity
     );
     let eth_address = (eth_address.into() + 1).try_into().unwrap();
-    verify_eth_signature::<Secp256k1Point>(:msg_hash, :signature, :eth_address);
+    verify_eth_signature(:msg_hash, :signature, :eth_address);
 }
 
 #[test]
 #[should_panic(expected: ('Signature out of range',))]
-#[available_gas(100000000)]
 fn test_verify_eth_signature_overflowing_signature_r() {
     let y_parity = true;
-    let (msg_hash, mut signature, expected_public_key_x, expected_public_key_y, eth_address) =
+    let (msg_hash, mut signature, _expected_public_key_x, _expected_public_key_y, eth_address) =
         get_message_and_signature(
         :y_parity
     );
     signature.r = Secp256k1Impl::get_curve_size() + 1;
-    verify_eth_signature::<Secp256k1Point>(:msg_hash, :signature, :eth_address);
+    verify_eth_signature(:msg_hash, :signature, :eth_address);
 }
 
 #[test]
 #[should_panic(expected: ('Signature out of range',))]
-#[available_gas(100000000)]
 fn test_verify_eth_signature_overflowing_signature_s() {
     let y_parity = true;
-    let (msg_hash, mut signature, expected_public_key_x, expected_public_key_y, eth_address) =
+    let (msg_hash, mut signature, _expected_public_key_x, _expected_public_key_y, eth_address) =
         get_message_and_signature(
         :y_parity
     );
     signature.s = Secp256k1Impl::get_curve_size() + 1;
-    verify_eth_signature::<Secp256k1Point>(:msg_hash, :signature, :eth_address);
+    verify_eth_signature(:msg_hash, :signature, :eth_address);
+}
+
+#[test]
+#[available_gas(100000000)]
+fn test_verify_signature() {
+    let (msg_hash, signature, public_key_x, public_key_y, _) = get_message_and_signature(false);
+
+    let public_key = Secp256k1Impl::secp256_ec_new_syscall(public_key_x, public_key_y)
+        .unwrap_syscall()
+        .unwrap();
+
+    let is_valid = is_valid_signature::<
+        Secp256k1Point
+    >(msg_hash, signature.r, signature.s, public_key);
+    assert(is_valid, 'Signature should be valid');
+}
+
+#[test]
+#[available_gas(100000000)]
+fn test_verify_signature_invalid_signature() {
+    let (msg_hash, signature, public_key_x, public_key_y, _) = get_message_and_signature(false);
+
+    let public_key = Secp256k1Impl::secp256_ec_new_syscall(public_key_x, public_key_y)
+        .unwrap_syscall()
+        .unwrap();
+
+    let is_valid = is_valid_signature::<
+        Secp256k1Point
+    >(msg_hash, signature.r + 1, signature.s, public_key);
+    assert(!is_valid, 'Signature should be invalid');
 }
diff --git a/corelib/src/test/secp256r1_test.cairo b/corelib/src/test/secp256r1_test.cairo
index ef1bdb3..325e93d 100644
--- a/corelib/src/test/secp256r1_test.cairo
+++ b/corelib/src/test/secp256r1_test.cairo
@@ -1,14 +1,9 @@
-use starknet::{
-    eth_address::U256IntoEthAddress, EthAddress, secp256r1::Secp256r1Impl, SyscallResultTrait
-};
-use starknet::secp256_trait::{
-    recover_public_key, verify_eth_signature, Secp256PointTrait, Signature
-};
+use starknet::{secp256r1::Secp256r1Impl, SyscallResultTrait};
+use starknet::secp256_trait::{recover_public_key, Secp256PointTrait, Signature, is_valid_signature};
 use starknet::secp256r1::{Secp256r1Point, Secp256r1PointImpl};
-use test::test_utils::assert_eq;
+use core::test::test_utils::assert_eq;
 
 #[test]
-#[available_gas(100000000)]
 fn test_secp256r1_recover_public_key() {
     let (msg_hash, signature, expected_public_key_x, expected_public_key_y, _) =
         get_message_and_signature();
@@ -20,7 +15,7 @@ fn test_secp256r1_recover_public_key() {
 
 
 /// Returns a golden valid message hash and its signature, for testing.
-fn get_message_and_signature() -> (u256, Signature, u256, u256, EthAddress) {
+fn get_message_and_signature() -> (u256, Signature, u256, u256, Secp256r1Point) {
     // msg = ""
     // public key: (0x04aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad5,
     //              0x0087d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d)
@@ -32,62 +27,66 @@ fn get_message_and_signature() -> (u256, Signature, u256, u256, EthAddress) {
         0x04aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad5,
         0x0087d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d
     );
-    let eth_address = 0x492882426e1cda979008bfaf874ff796eb3bb1c0_u256.into();
 
-    (msg_hash, Signature { r, s, y_parity: true }, public_key_x, public_key_y, eth_address)
+    let public_key = Secp256r1Impl::secp256_ec_new_syscall(public_key_x, public_key_y)
+        .unwrap_syscall()
+        .unwrap();
+
+    (msg_hash, Signature { r, s, y_parity: true }, public_key_x, public_key_y, public_key)
 }
 
 #[test]
 #[available_gas(100000000)]
-fn test_verify_eth_signature() {
-    let (msg_hash, signature, expected_public_key_x, expected_public_key_y, eth_address) =
-        get_message_and_signature();
-    verify_eth_signature::<Secp256r1Point>(:msg_hash, :signature, :eth_address);
+fn test_verify_signature() {
+    let (msg_hash, signature, _, _, public_key) = get_message_and_signature();
+    let is_valid = is_valid_signature::<
+        Secp256r1Point
+    >(msg_hash, signature.r, signature.s, public_key);
+    assert(is_valid, 'Signature should be valid');
 }
 
 #[test]
-#[should_panic(expected: ('Invalid signature',))]
 #[available_gas(100000000)]
-fn test_verify_eth_signature_wrong_eth_address() {
-    let (msg_hash, signature, expected_public_key_x, expected_public_key_y, eth_address) =
-        get_message_and_signature();
-    let eth_address = (eth_address.into() + 1).try_into().unwrap();
-    verify_eth_signature::<Secp256r1Point>(:msg_hash, :signature, :eth_address);
+fn test_verify_signature_invalid_signature() {
+    let (msg_hash, signature, _, _, public_key) = get_message_and_signature();
+    let is_valid = is_valid_signature::<
+        Secp256r1Point
+    >(msg_hash, signature.r + 1, signature.s, public_key);
+    assert(!is_valid, 'Signature should be invalid');
 }
 
 #[test]
-#[should_panic(expected: ('Signature out of range',))]
 #[available_gas(100000000)]
-fn test_verify_eth_signature_overflowing_signature_r() {
-    let (msg_hash, mut signature, expected_public_key_x, expected_public_key_y, eth_address) =
-        get_message_and_signature();
-    signature.r = Secp256r1Impl::get_curve_size() + 1;
-    verify_eth_signature::<Secp256r1Point>(:msg_hash, :signature, :eth_address);
+fn test_verify_signature_overflowing_signature_r() {
+    let (msg_hash, mut signature, _, _, public_key) = get_message_and_signature();
+    let is_valid = is_valid_signature::<
+        Secp256r1Point
+    >(msg_hash, Secp256r1Impl::get_curve_size() + 1, signature.s, public_key);
+    assert(!is_valid, 'Signature out of range');
 }
 
 #[test]
-#[should_panic(expected: ('Signature out of range',))]
 #[available_gas(100000000)]
-fn test_verify_eth_signature_overflowing_signature_s() {
-    let (msg_hash, mut signature, expected_public_key_x, expected_public_key_y, eth_address) =
-        get_message_and_signature();
-    signature.s = Secp256r1Impl::get_curve_size() + 1;
-    verify_eth_signature::<Secp256r1Point>(:msg_hash, :signature, :eth_address);
+fn test_verify_signature_overflowing_signature_s() {
+    let (msg_hash, mut signature, _, _, public_key) = get_message_and_signature();
+    let is_valid = is_valid_signature::<
+        Secp256r1Point
+    >(msg_hash, signature.r, Secp256r1Impl::get_curve_size() + 1, public_key);
+    assert(!is_valid, 'Signature out of range');
 }
 
 
 #[test]
-#[available_gas(100_000_000)]
 fn test_recover_public_key_y_even() {
     let x: u256 = 0x502a43ce77c6f5c736a82f847fa95f8c2d483fe223b12b91047d83258a958b0f;
-    let y: u256 = 0xdb0a2e6710c71ba80afeb3abdf69d306ce729c7704f4ddf2eaaf0b76209fe1b0;
+    let _y: u256 = 0xdb0a2e6710c71ba80afeb3abdf69d306ce729c7704f4ddf2eaaf0b76209fe1b0;
     let r: u256 = 0x7380df4a623c5c2259a5e5f5b225d7265a9e24b3a13c101d1afddcf29e3cf8b2;
     let s: u256 = 0x0d131afacdd17a4ea1b544bb3ade677ff8accbe7830e15b9c225e6031155946a;
     let y_parity = false;
     let message_hash: u256 = 0x28c7fff9aef4847a82cd64280434712a5b49205831b60eea6e70614077e672eb;
     let recovered = recover_public_key::<Secp256r1Point>(message_hash, Signature { r, s, y_parity })
         .unwrap();
-    let (recovered_x, recovered_y) = recovered.get_coordinates().unwrap_syscall();
+    let (recovered_x, _recovered_y) = recovered.get_coordinates().unwrap_syscall();
 
     assert_eq(@recovered_x, @x, 'Signature is not valid');
 }
diff --git a/corelib/src/test/test_utils.cairo b/corelib/src/test/test_utils.cairo
index bd001de..cd808a1 100644
--- a/corelib/src/test/test_utils.cairo
+++ b/corelib/src/test/test_utils.cairo
@@ -1,29 +1,29 @@
 #[inline]
-fn assert_eq<T, impl TPartialEq: PartialEq<T>>(a: @T, b: @T, err_code: felt252) {
+pub fn assert_eq<T, +PartialEq<T>>(a: @T, b: @T, err_code: felt252) {
     assert(a == b, err_code);
 }
 
 #[inline]
-fn assert_ne<T, impl TPartialEq: PartialEq<T>>(a: @T, b: @T, err_code: felt252) {
+pub fn assert_ne<T, +PartialEq<T>>(a: @T, b: @T, err_code: felt252) {
     assert(a != b, err_code);
 }
 
 #[inline]
-fn assert_le<T, impl TPartialOrd: PartialOrd<T>>(a: T, b: T, err_code: felt252) {
+pub fn assert_le<T, +PartialOrd<T>>(a: T, b: T, err_code: felt252) {
     assert(a <= b, err_code);
 }
 
 #[inline]
-fn assert_lt<T, impl TPartialOrd: PartialOrd<T>>(a: T, b: T, err_code: felt252) {
+pub fn assert_lt<T, +PartialOrd<T>>(a: T, b: T, err_code: felt252) {
     assert(a < b, err_code);
 }
 
 #[inline]
-fn assert_ge<T, impl TPartialOrd: PartialOrd<T>>(a: T, b: T, err_code: felt252) {
+pub fn assert_ge<T, +PartialOrd<T>>(a: T, b: T, err_code: felt252) {
     assert(a >= b, err_code);
 }
 
 #[inline]
-fn assert_gt<T, impl TPartialOrd: PartialOrd<T>>(a: T, b: T, err_code: felt252) {
+pub fn assert_gt<T, +PartialOrd<T>>(a: T, b: T, err_code: felt252) {
     assert(a > b, err_code);
 }
diff --git a/corelib/src/test/testing_test.cairo b/corelib/src/test/testing_test.cairo
index 7d80eb6..6e5e564 100644
--- a/corelib/src/test/testing_test.cairo
+++ b/corelib/src/test/testing_test.cairo
@@ -1,14 +1,14 @@
-use test::test_utils::{assert_eq, assert_ne, assert_gt};
+use core::test::test_utils::assert_gt;
 
 #[test]
 #[should_panic(expected: ('panic_with_felt252()',))]
 fn test_panic_with_felt252() {
     // No semicolon here: Missing implementation for core::traits::Drop::<core::never>
-    panic_with_felt252('panic_with_felt252()')
+    core::panic_with_felt252('panic_with_felt252()')
 }
 
 #[test]
-#[should_panic(expected: ('assert(false)',))]
+#[should_panic(expected: 'assert(false)')]
 fn test_assert_false() {
     assert(false, 'assert(false)');
 }
@@ -19,12 +19,64 @@ fn test_assert_true() {
 }
 
 #[test]
+#[should_panic(expected: "assert(false)")]
+fn test_assert_macro_false() {
+    assert!(false, "assert(false)");
+}
+
+#[test]
+fn test_assert_macro_true() {
+    assert!(true, "assert(true)");
+}
+
+#[test]
+fn test_assert_ne_with_description() {
+    assert_ne!(1, 2, "Description");
+}
+
+#[test]
+fn test_assert_ne_no_description() {
+    assert_ne!(1, 2);
+}
+
+#[test]
+#[should_panic(expected: "assertion failed: `false`.")]
+fn test_assert_macro_no_input() {
+    assert!(false);
+}
+
+#[test]
+#[should_panic(expected: "assertion `1 == 2` failed: Description
+1: 1
+2: 2")]
+fn test_assert_eq_with_description() {
+    assert_eq!(1, 2, "Description");
+}
+
+#[test]
+#[should_panic(expected: "assertion `1 == 2` failed: 1 != 2
+1: 1
+2: 2")]
+fn test_assert_eq_with_formatted_description() {
+    assert_eq!(1, 2, "{} != {}", 1, 2);
+}
+
+#[test]
+#[should_panic(expected: "assertion `1 == 2` failed.
+1: 1
+2: 2")]
+fn test_assert_eq_no_description() {
+    assert_eq!(1, 2);
+}
+
+#[test]
+#[available_gas(static)]
 fn test_get_available_gas_no_gas_supply() {
-    assert_eq(@testing::get_available_gas(), @0, 'expected no_gas_supply')
+    assert_eq!(core::testing::get_available_gas(), 0)
 }
 
 #[test]
 #[available_gas(10000)]
 fn test_get_available_gas_with_gas_supply() {
-    assert_gt(testing::get_available_gas(), 5000, 'high amount of gas used')
+    assert_gt(core::testing::get_available_gas(), 5000, 'high amount of gas used')
 }
diff --git a/corelib/src/test/to_byte_array_test.cairo b/corelib/src/test/to_byte_array_test.cairo
new file mode 100644
index 0000000..8d6f814
--- /dev/null
+++ b/corelib/src/test/to_byte_array_test.cairo
@@ -0,0 +1,249 @@
+use core::test::test_utils::assert_eq;
+use core::to_byte_array::{FormatAsByteArray, AppendFormattedToByteArray};
+
+#[test]
+fn test_to_string_hex() {
+    let hex_base: NonZero<u8> = 16_u8.try_into().unwrap();
+
+    let expected_string = "0";
+    let serialized = 0_u8.format_as_byte_array(hex_base);
+    assert_eq(@serialized, @expected_string, 'Bad hex representation of 0');
+
+    let expected_string = "a";
+    let serialized = 0xa_u8.format_as_byte_array(hex_base);
+    assert_eq(@serialized, @expected_string, 'Bad hex representation of 10');
+
+    let expected_string = "6f";
+    let serialized = 0x6f_u8.format_as_byte_array(hex_base);
+    assert_eq(@serialized, @expected_string, 'Bad hex representation of 111');
+
+    let expected_string = "ff";
+    let serialized = 0xff_u8.format_as_byte_array(hex_base);
+    assert_eq(@serialized, @expected_string, 'Bad hex representation of 255');
+
+    // Other uint types:
+    let expected_string = "6f";
+    let serialized = 0x6f_u16.format_as_byte_array(base: 16_u16.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u16 hex representation');
+    let serialized = 0x6f_u32.format_as_byte_array(base: 16_u32.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u32 hex representation');
+    let serialized = 0x6f_u64.format_as_byte_array(base: 16_u64.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u64 hex representation');
+    let serialized = 0x6f_u128.format_as_byte_array(base: 16_u128.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u128 hex representation');
+    let serialized = 0x6f_u256.format_as_byte_array(base: 16_u256.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u256 hex representation');
+    let serialized = 0x6f_felt252.format_as_byte_array(base: 16.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad felt252 hex representation');
+}
+#[test]
+fn test_to_string_dec() {
+    let dec_base: NonZero<u8> = 10_u8.try_into().unwrap();
+
+    let expected_string = "0";
+    let serialized = 0_u8.format_as_byte_array(dec_base);
+    assert_eq(@serialized, @expected_string, 'Bad dec representation of 0');
+
+    let expected_string = "10";
+    let serialized = 10_u8.format_as_byte_array(dec_base);
+    assert_eq(@serialized, @expected_string, 'Bad dec representation of 10');
+
+    let expected_string = "111";
+    let serialized = 111_u8.format_as_byte_array(dec_base);
+    assert_eq(@serialized, @expected_string, 'Bad dec representation of 111');
+
+    let expected_string = "255";
+    let serialized = 255_u8.format_as_byte_array(dec_base);
+    assert_eq(@serialized, @expected_string, 'Bad dec representation of 255');
+
+    // Other uint types:
+    let expected_string = "111";
+    let serialized = 111_u16.format_as_byte_array(base: 10_u16.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u16 dec representation');
+    let serialized = 111_u32.format_as_byte_array(base: 10_u32.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u32 dec representation');
+    let serialized = 111_u64.format_as_byte_array(base: 10_u64.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u64 dec representation');
+    let serialized = 111_u128.format_as_byte_array(base: 10_u128.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u128 dec representation');
+    let serialized = 111_u256.format_as_byte_array(base: 10_u256.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u256 dec representation');
+    let serialized = 111_felt252.format_as_byte_array(base: 10.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad felt252 dec representation');
+}
+
+#[test]
+fn test_to_string_oct() {
+    let oct_base: NonZero<u8> = 8_u8.try_into().unwrap();
+
+    let expected_string = "0";
+    let serialized = 0_u8.format_as_byte_array(oct_base);
+    assert_eq(@serialized, @expected_string, 'Bad oct representation of 0');
+
+    let expected_string = "12";
+    let serialized = 10_u8.format_as_byte_array(oct_base);
+    assert_eq(@serialized, @expected_string, 'Bad oct representation of 10');
+
+    let expected_string = "157";
+    let serialized = 111_u8.format_as_byte_array(oct_base);
+    assert_eq(@serialized, @expected_string, 'Bad oct representation of 111');
+
+    let expected_string = "377";
+    let serialized = 255_u8.format_as_byte_array(oct_base);
+    assert_eq(@serialized, @expected_string, 'Bad oct representation of 255');
+
+    // Other uint types:
+    let expected_string = "157";
+    let serialized = 111_u16.format_as_byte_array(base: 8_u16.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u16 oct representation');
+    let serialized = 111_u32.format_as_byte_array(base: 8_u32.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u32 oct representation');
+    let serialized = 111_u64.format_as_byte_array(base: 8_u64.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u64 oct representation');
+    let serialized = 111_u128.format_as_byte_array(base: 8_u128.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u128 oct representation');
+    let serialized = 111_u256.format_as_byte_array(base: 8_u256.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u256 oct representation');
+    let serialized = 111_felt252.format_as_byte_array(base: 8.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad felt252 oct representation');
+}
+
+#[test]
+fn test_to_string_bin() {
+    let bin_base: NonZero<u8> = 2_u8.try_into().unwrap();
+
+    let expected_string = "0";
+    let serialized = 0_u8.format_as_byte_array(bin_base);
+    assert_eq(@serialized, @expected_string, 'Bad bin representation of 0');
+
+    let expected_string = "1010";
+    let serialized = 10_u8.format_as_byte_array(bin_base);
+    assert_eq(@serialized, @expected_string, 'Bad bin representation of 10');
+
+    let expected_string = "1101111";
+    let serialized = 111_u8.format_as_byte_array(bin_base);
+    assert_eq(@serialized, @expected_string, 'Bad bin representation of 111');
+
+    let expected_string = "11111111";
+    let serialized = 255_u8.format_as_byte_array(bin_base);
+    assert_eq(@serialized, @expected_string, 'Bad bin representation of 255');
+
+    // Other uint types:
+    let expected_string = "1101111";
+    let serialized = 111_u16.format_as_byte_array(base: 2_u16.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u16 bin representation');
+    let serialized = 111_u32.format_as_byte_array(base: 2_u32.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u32 bin representation');
+    let serialized = 111_u64.format_as_byte_array(base: 2_u64.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u64 bin representation');
+    let serialized = 111_u128.format_as_byte_array(base: 2_u128.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u128 bin representation');
+    let serialized = 111_u256.format_as_byte_array(base: 2_u256.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u256 bin representation');
+    let serialized = 111_felt252.format_as_byte_array(base: 2.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad felt252 bin representation');
+}
+
+#[test]
+fn test_to_string_base7() {
+    let base7: NonZero<u8> = 7_u8.try_into().unwrap();
+
+    let expected_string = "0";
+    let serialized = 0_u8.format_as_byte_array(base7);
+    assert_eq(@serialized, @expected_string, 'Bad b7 representation of 0');
+
+    let expected_string = "13";
+    let serialized = 10_u8.format_as_byte_array(base7);
+    assert_eq(@serialized, @expected_string, 'Bad b7 representation of 10');
+
+    let expected_string = "216";
+    let serialized = 111_u8.format_as_byte_array(base7);
+    assert_eq(@serialized, @expected_string, 'Bad b7 representation of 111');
+
+    let expected_string = "513";
+    let serialized = 255_u8.format_as_byte_array(base7);
+    assert_eq(@serialized, @expected_string, 'Bad b7 representation of 255');
+
+    // Other uint types:
+    let expected_string = "216";
+    let serialized = 111_u16.format_as_byte_array(base: 7_u16.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u16 b7 representation');
+    let serialized = 111_u32.format_as_byte_array(base: 7_u32.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u32 b7 representation');
+    let serialized = 111_u64.format_as_byte_array(base: 7_u64.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u64 b7 representation');
+    let serialized = 111_u128.format_as_byte_array(base: 7_u128.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u128 b7 representation');
+    let serialized = 111_u256.format_as_byte_array(base: 7_u256.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u256 b7 representation');
+    let serialized = 111_felt252.format_as_byte_array(base: 7.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad felt252 b7 representation');
+}
+
+#[test]
+fn test_to_string_base36() {
+    let base36: NonZero<u8> = 36_u8.try_into().unwrap();
+
+    let expected_string = "0";
+    let serialized = 0_u8.format_as_byte_array(base36);
+    assert_eq(@serialized, @expected_string, 'Bad b36 representation of 0');
+
+    let expected_string = "a";
+    let serialized = 10_u8.format_as_byte_array(base36);
+    assert_eq(@serialized, @expected_string, 'Bad b36 representation of 10');
+
+    let expected_string = "3z";
+    let serialized = 143_u8.format_as_byte_array(base36);
+    assert_eq(@serialized, @expected_string, 'Bad b36 representation of 143');
+
+    let expected_string = "73";
+    let serialized = 255_u8.format_as_byte_array(base36);
+    assert_eq(@serialized, @expected_string, 'Bad b36 representation of 255');
+
+    // Other uint types:
+    let expected_string = "3z";
+    let serialized = 143_u16.format_as_byte_array(base: 36_u16.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u16 b36 representation');
+    let serialized = 143_u32.format_as_byte_array(base: 36_u32.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u32 b36 representation');
+    let serialized = 143_u64.format_as_byte_array(base: 36_u64.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u64 b36 representation');
+    let serialized = 143_u128.format_as_byte_array(base: 36_u128.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u128 b36 representation');
+    let serialized = 143_u256.format_as_byte_array(base: 36_u256.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad u256 b36 representation');
+    let serialized = 143_felt252.format_as_byte_array(base: 36.try_into().unwrap());
+    assert_eq(@serialized, @expected_string, 'Bad felt252 b36 representation');
+}
+
+#[test]
+fn test_append() {
+    let expected = "prefix_6f";
+    let mut byte_array = "prefix_";
+    111_u8.append_formatted_to_byte_array(ref byte_array, base: 16_u8.try_into().unwrap());
+    assert_eq(@byte_array, @expected, 'Bad append u8');
+
+    let mut byte_array = "prefix_";
+    111_u16.append_formatted_to_byte_array(ref byte_array, base: 16_u16.try_into().unwrap());
+    assert_eq(@byte_array, @expected, 'Bad append u16');
+
+    let mut byte_array = "prefix_";
+    111_u32.append_formatted_to_byte_array(ref byte_array, base: 16_u32.try_into().unwrap());
+    assert_eq(@byte_array, @expected, 'Bad append u32');
+
+    let mut byte_array = "prefix_";
+    111_u64.append_formatted_to_byte_array(ref byte_array, base: 16_u64.try_into().unwrap());
+    assert_eq(@byte_array, @expected, 'Bad append u64');
+
+    let mut byte_array = "prefix_";
+    111_u128.append_formatted_to_byte_array(ref byte_array, base: 16_u128.try_into().unwrap());
+    assert_eq(@byte_array, @expected, 'Bad append u128');
+
+    let mut byte_array = "prefix_";
+    111_u256.append_formatted_to_byte_array(ref byte_array, base: 16_u256.try_into().unwrap());
+    assert_eq(@byte_array, @expected, 'Bad append u256');
+
+    let mut byte_array = "prefix_";
+    111.append_formatted_to_byte_array(ref byte_array, base: 16.try_into().unwrap());
+    assert_eq(@byte_array, @expected, 'Bad append felt252');
+}
diff --git a/corelib/src/testing.cairo b/corelib/src/testing.cairo
index e65f9ae..f7dc0ff 100644
--- a/corelib/src/testing.cairo
+++ b/corelib/src/testing.cairo
@@ -1 +1 @@
-extern fn get_available_gas() -> u128 implicits(GasBuiltin) nopanic;
+pub extern fn get_available_gas() -> u128 implicits(GasBuiltin) nopanic;
diff --git a/corelib/src/to_byte_array.cairo b/corelib/src/to_byte_array.cairo
new file mode 100644
index 0000000..1ee7899
--- /dev/null
+++ b/corelib/src/to_byte_array.cairo
@@ -0,0 +1,129 @@
+use core::byte_array::ByteArrayTrait;
+use core::traits::{Into, TryInto};
+use core::option::OptionTrait;
+use core::zeroable::Zeroable;
+
+/// Formats a type that behaves like uint to its Ascii representation and appends the formatted
+/// result into the given ByteArray.
+pub trait AppendFormattedToByteArray<T> {
+    fn append_formatted_to_byte_array(self: @T, ref byte_array: ByteArray, base: NonZero<T>);
+}
+
+/// Formats the given input of a type that behaves like uint to its Ascii representation in a
+/// ByteArray.
+pub trait FormatAsByteArray<T> {
+    fn format_as_byte_array(self: @T, base: NonZero<T>) -> ByteArray;
+}
+
+impl FormatAsByteArrayImpl<T, +AppendFormattedToByteArray<T>> of FormatAsByteArray<T> {
+    fn format_as_byte_array(self: @T, base: NonZero<T>) -> ByteArray {
+        let mut byte_array = "";
+        self.append_formatted_to_byte_array(ref byte_array, :base);
+        byte_array
+    }
+}
+
+// === Impls of AppendFormattedToByteArray ===
+
+impl U8AppendFormattedToByteArray of AppendFormattedToByteArray<u8> {
+    fn append_formatted_to_byte_array(self: @u8, ref byte_array: ByteArray, base: NonZero<u8>) {
+        append_formatted_to_byte_array(self, ref byte_array, base);
+    }
+}
+impl U16AppendFormattedToByteArray of AppendFormattedToByteArray<u16> {
+    fn append_formatted_to_byte_array(self: @u16, ref byte_array: ByteArray, base: NonZero<u16>) {
+        append_formatted_to_byte_array(self, ref byte_array, base);
+    }
+}
+impl U32AppendFormattedToByteArray of AppendFormattedToByteArray<u32> {
+    fn append_formatted_to_byte_array(self: @u32, ref byte_array: ByteArray, base: NonZero<u32>) {
+        append_formatted_to_byte_array(self, ref byte_array, base);
+    }
+}
+impl U64AppendFormattedToByteArray of AppendFormattedToByteArray<u64> {
+    fn append_formatted_to_byte_array(self: @u64, ref byte_array: ByteArray, base: NonZero<u64>) {
+        append_formatted_to_byte_array(self, ref byte_array, base);
+    }
+}
+impl U128AppendFormattedToByteArray of AppendFormattedToByteArray<u128> {
+    fn append_formatted_to_byte_array(self: @u128, ref byte_array: ByteArray, base: NonZero<u128>) {
+        append_formatted_to_byte_array(self, ref byte_array, base);
+    }
+}
+impl U256AppendFormattedToByteArray of AppendFormattedToByteArray<u256> {
+    fn append_formatted_to_byte_array(self: @u256, ref byte_array: ByteArray, base: NonZero<u256>) {
+        append_formatted_to_byte_array(self, ref byte_array, base);
+    }
+}
+impl Felt252AppendFormattedToByteArray of AppendFormattedToByteArray<felt252> {
+    fn append_formatted_to_byte_array(
+        self: @felt252, ref byte_array: ByteArray, base: NonZero<felt252>
+    ) {
+        let self_as_u256: u256 = (*self).into();
+        let base: felt252 = base.into();
+        let base: u256 = base.into();
+        let base: NonZero<u256> = base.try_into().unwrap();
+        self_as_u256.append_formatted_to_byte_array(ref byte_array, base);
+    }
+}
+
+// === helper functions ===
+
+// TODO(yuval): once const generic parameters are supported, move base_nz to be a generic
+// parameter. Same for the other bases.
+// TODO(yuval): support signed integers.
+/// Formats a type that behaves like uint to its Ascii representation and appends the formatted
+/// result into the given ByteArray.
+/// `base` must be in the range [2, 36]. Otherwise, this function panics.
+fn append_formatted_to_byte_array<
+    T, +Drop<T>, +Copy<T>, +DivRem<T>, +TryInto<T, u8>, +Zeroable<T>,
+>(
+    mut value: @T, ref byte_array: ByteArray, base_nz: NonZero<T>,
+) {
+    let base: T = base_nz.into();
+    let base: u8 = base.try_into().unwrap();
+    assert(base > 1, 'base must be > 1');
+    assert(base <= 36, 'base must be <= 36');
+
+    let mut reversed_digits = array![];
+
+    if base <= 10 {
+        loop {
+            let (new_value, digit) = DivRem::div_rem(*value, base_nz);
+            value = @new_value;
+            let digit_as_u8: u8 = digit.try_into().unwrap();
+            reversed_digits.append(digit_as_u8 + '0');
+            if (*value).is_zero() {
+                break;
+            };
+        }
+    } else {
+        loop {
+            let (new_value, digit) = DivRem::div_rem(*value, base_nz);
+            value = @new_value;
+            let digit_as_u8: u8 = digit.try_into().unwrap();
+            reversed_digits.append(get_big_base_digit_representation(:digit_as_u8));
+            if (*value).is_zero() {
+                break;
+            };
+        };
+    }
+
+    let mut span = reversed_digits.span();
+    loop {
+        match span.pop_back() {
+            Option::Some(byte) => { byte_array.append_byte(*byte); },
+            Option::None => { break; },
+        };
+    };
+}
+
+/// Converts a digit (0-9, A-Z) to its Ascii representation in a base > 10.
+#[inline]
+fn get_big_base_digit_representation(digit_as_u8: u8) -> u8 {
+    if digit_as_u8 < 10 {
+        digit_as_u8 + '0'
+    } else {
+        digit_as_u8 - 10 + 'a'
+    }
+}
diff --git a/corelib/src/traits.cairo b/corelib/src/traits.cairo
index 1ae2113..0ec69bd 100644
--- a/corelib/src/traits.cairo
+++ b/corelib/src/traits.cairo
@@ -1,90 +1,90 @@
 use core::panics::Panic;
 
-trait Copy<T>;
-trait Drop<T>;
+pub trait Copy<T>;
+pub trait Drop<T>;
 
 impl SnapshotCopy<T> of Copy<@T>;
 impl SnapshotDrop<T> of Drop<@T>;
 
 // TODO(spapini): When associated types are supported, support the general trait Add<X, Y>.
-trait Add<T> {
+pub trait Add<T> {
     fn add(lhs: T, rhs: T) -> T;
 }
-trait AddEq<T> {
+pub trait AddEq<T> {
     fn add_eq(ref self: T, other: T);
 }
 
 // TODO(spapini): When associated types are supported, support the general trait Sub<X, Y>.
-trait Sub<T> {
+pub trait Sub<T> {
     fn sub(lhs: T, rhs: T) -> T;
 }
-trait SubEq<T> {
+pub trait SubEq<T> {
     fn sub_eq(ref self: T, other: T);
 }
 
 // TODO(spapini): When associated types are supported, support the general trait Mul<X, Y>.
-trait Mul<T> {
+pub trait Mul<T> {
     fn mul(lhs: T, rhs: T) -> T;
 }
-trait MulEq<T> {
+pub trait MulEq<T> {
     fn mul_eq(ref self: T, other: T);
 }
 
 // TODO(spapini): When associated types are supported, support the general trait Div<X, Y>.
-trait Div<T> {
+pub trait Div<T> {
     fn div(lhs: T, rhs: T) -> T;
 }
-trait DivEq<T> {
+pub trait DivEq<T> {
     fn div_eq(ref self: T, other: T);
 }
 
 // TODO(spapini): When associated types are supported, support the general trait Rem<X, Y>.
-trait Rem<T> {
+pub trait Rem<T> {
     fn rem(lhs: T, rhs: T) -> T;
 }
-trait RemEq<T> {
+pub trait RemEq<T> {
     fn rem_eq(ref self: T, other: T);
 }
 
 // TODO(spapini): When associated types are supported, support the general trait DivRem<X, Y>.
 /// Division with remainder.
-trait DivRem<T> {
+pub trait DivRem<T> {
     fn div_rem(lhs: T, rhs: NonZero<T>) -> (T, T);
 }
 
-trait PartialEq<T> {
+pub trait PartialEq<T> {
     fn eq(lhs: @T, rhs: @T) -> bool;
     fn ne(lhs: @T, rhs: @T) -> bool;
 }
-impl PartialEqSnap<T, impl TEq: PartialEq<T>> of PartialEq<@T> {
+impl PartialEqSnap<T, +PartialEq<T>> of PartialEq<@T> {
     fn eq(lhs: @@T, rhs: @@T) -> bool {
-        TEq::eq(*lhs, *rhs)
+        PartialEq::<T>::eq(*lhs, *rhs)
     }
     fn ne(lhs: @@T, rhs: @@T) -> bool {
-        TEq::ne(*lhs, *rhs)
+        PartialEq::<T>::ne(*lhs, *rhs)
     }
 }
 
 // TODO(spapini): When associated types are supported, support the general trait BitAnd<X, Y>.
-trait BitAnd<T> {
+pub trait BitAnd<T> {
     fn bitand(lhs: T, rhs: T) -> T;
 }
 
 // TODO(spapini): When associated types are supported, support the general trait BitOr<X, Y>.
-trait BitOr<T> {
+pub trait BitOr<T> {
     fn bitor(lhs: T, rhs: T) -> T;
 }
 
 // TODO(spapini): When associated types are supported, support the general trait BitXor<X, Y>.
-trait BitXor<T> {
+pub trait BitXor<T> {
     fn bitxor(lhs: T, rhs: T) -> T;
 }
 
-trait BitNot<T> {
+pub trait BitNot<T> {
     fn bitnot(a: T) -> T;
 }
 
-trait PartialOrd<T> {
+pub trait PartialOrd<T> {
     fn le(lhs: T, rhs: T) -> bool;
     fn ge(lhs: T, rhs: T) -> bool;
     fn lt(lhs: T, rhs: T) -> bool;
@@ -92,7 +92,8 @@ trait PartialOrd<T> {
 }
 
 /// Trait for conversion between types.
-trait Into<T, S> {
+pub trait Into<T, S> {
+    #[must_use]
     fn into(self: T) -> S;
 }
 
@@ -103,53 +104,60 @@ impl TIntoT<T> of Into<T, T> {
 }
 
 /// Trait for fallible conversion between types.
-trait TryInto<T, S> {
+pub trait TryInto<T, S> {
     fn try_into(self: T) -> Option<S>;
 }
 
-trait Neg<T> {
+impl TryIntoFromInto<From, To, +Into<From, To>> of TryInto<From, To> {
+    fn try_into(self: From) -> Option<To> {
+        Option::Some(self.into())
+    }
+}
+
+pub trait Neg<T> {
     fn neg(a: T) -> T;
 }
 
-trait Not<T> {
+pub trait Not<T> {
     fn not(a: T) -> T;
 }
 
 /// The following two traits are for implementing the [] operator. Only one should be implemented
 /// for each type. Both are not consuming of self, the first gets a snapshot of the object and
 /// the second gets ref.
-trait IndexView<C, I, V> {
+pub trait IndexView<C, I, V> {
     fn index(self: @C, index: I) -> V;
 }
 
-trait Index<C, I, V> {
+pub trait Index<C, I, V> {
     fn index(ref self: C, index: I) -> V;
 }
 
-trait Destruct<T> {
+pub trait Destruct<T> {
     fn destruct(self: T) nopanic;
 }
 // TODO(spapini): Remove this, it can lead to multiple impls and unwanted Destruct implementation.
-impl DestructFromDrop<T, impl TDrop: Drop<T>> of Destruct<T> {
+impl DestructFromDrop<T, +Drop<T>> of Destruct<T> {
     #[inline(always)]
     fn destruct(self: T) nopanic {}
 }
 
-trait PanicDestruct<T> {
+pub trait PanicDestruct<T> {
     fn panic_destruct(self: T, ref panic: Panic) nopanic;
 }
-impl PanicDestructForDestruct<T, impl TDestruct: Destruct<T>> of PanicDestruct<T> {
+impl PanicDestructForDestruct<T, +Destruct<T>> of PanicDestruct<T> {
     #[inline(always)]
     fn panic_destruct(self: T, ref panic: Panic) nopanic {
-        TDestruct::destruct(self);
+        Destruct::destruct(self);
     }
 }
 
-trait Default<T> {
+pub trait Default<T> {
+    #[must_use]
     fn default() -> T;
 }
 
-impl SnapshotDefault<T, impl TDefault: Default<T>, impl TDrop: Drop<T>> of Default<@T> {
+impl SnapshotDefault<T, +Default<T>, +Drop<T>> of Default<@T> {
     #[inline(always)]
     fn default() -> @T {
         @Default::default()
@@ -157,54 +165,37 @@ impl SnapshotDefault<T, impl TDefault: Default<T>, impl TDrop: Drop<T>> of Defau
 }
 
 /// Trait for types allowed as values in a Felt252Dict.
-trait Felt252DictValue<T> {
+pub trait Felt252DictValue<T> {
     /// Returns the default value for this type as a value in a Felt252Dict.
     /// Should be logically equivalent to 0.
+    #[must_use]
     fn zero_default() -> T nopanic;
 }
 
 // Tuple Copy impls.
-impl TupleSize0Copy of Copy<()>;
+pub(crate) impl TupleSize0Copy of Copy<()>;
 
-impl TupleSize1Copy<E0, impl E0Copy: Copy<E0>> of Copy<(E0,)>;
+impl TupleSize1Copy<E0, +Copy<E0>> of Copy<(E0,)>;
 
-impl TupleSize2Copy<E0, E1, impl E0Copy: Copy<E0>, impl E1Copy: Copy<E1>> of Copy<(E0, E1)>;
+impl TupleSize2Copy<E0, E1, +Copy<E0>, +Copy<E1>> of Copy<(E0, E1)>;
 
-impl TupleSize3Copy<
-    E0, E1, E2, impl E0Copy: Copy<E0>, impl E1Copy: Copy<E1>, impl E2Copy: Copy<E2>
-> of Copy<(E0, E1, E2)>;
+impl TupleSize3Copy<E0, E1, E2, +Copy<E0>, +Copy<E1>, +Copy<E2>> of Copy<(E0, E1, E2)>;
 
 impl TupleSize4Copy<
-    E0,
-    E1,
-    E2,
-    E3,
-    impl E0Copy: Copy<E0>,
-    impl E1Copy: Copy<E1>,
-    impl E2Copy: Copy<E2>,
-    impl E3Copy: Copy<E3>
+    E0, E1, E2, E3, +Copy<E0>, +Copy<E1>, +Copy<E2>, +Copy<E3>
 > of Copy<(E0, E1, E2, E3)>;
 
 // Tuple Drop impls.
-impl TupleSize0Drop of Drop<()>;
+pub(crate) impl TupleSize0Drop of Drop<()>;
 
-impl TupleSize1Drop<E0, impl E0Drop: Drop<E0>> of Drop<(E0,)>;
+impl TupleSize1Drop<E0, +Drop<E0>> of Drop<(E0,)>;
 
-impl TupleSize2Drop<E0, E1, impl E0Drop: Drop<E0>, impl E1Drop: Drop<E1>> of Drop<(E0, E1)>;
+impl TupleSize2Drop<E0, E1, +Drop<E0>, +Drop<E1>> of Drop<(E0, E1)>;
 
-impl TupleSize3Drop<
-    E0, E1, E2, impl E0Drop: Drop<E0>, impl E1Drop: Drop<E1>, impl E2Drop: Drop<E2>
-> of Drop<(E0, E1, E2)>;
+impl TupleSize3Drop<E0, E1, E2, +Drop<E0>, +Drop<E1>, +Drop<E2>> of Drop<(E0, E1, E2)>;
 
 impl TupleSize4Drop<
-    E0,
-    E1,
-    E2,
-    E3,
-    impl E0Drop: Drop<E0>,
-    impl E1Drop: Drop<E1>,
-    impl E2Drop: Drop<E2>,
-    impl E2Drop: Drop<E3>
+    E0, E1, E2, E3, +Drop<E0>, +Drop<E1>, +Drop<E2>, +Drop<E3>
 > of Drop<(E0, E1, E2, E3)>;
 
 // Tuple PartialEq impls.
@@ -219,7 +210,7 @@ impl TupleSize0PartialEq of PartialEq<()> {
     }
 }
 
-impl TupleSize1PartialEq<E0, impl E0PartialEq: PartialEq<E0>> of PartialEq<(E0,)> {
+impl TupleSize1PartialEq<E0, +PartialEq<E0>> of PartialEq<(E0,)> {
     #[inline(always)]
     fn eq(lhs: @(E0,), rhs: @(E0,)) -> bool {
         let (lhs,) = lhs;
@@ -232,9 +223,7 @@ impl TupleSize1PartialEq<E0, impl E0PartialEq: PartialEq<E0>> of PartialEq<(E0,)
     }
 }
 
-impl TupleSize2PartialEq<
-    E0, E1, impl E0PartialEq: PartialEq<E0>, impl E1PartialEq: PartialEq<E1>
-> of PartialEq<(E0, E1)> {
+impl TupleSize2PartialEq<E0, E1, +PartialEq<E0>, +PartialEq<E1>> of PartialEq<(E0, E1)> {
     #[inline(always)]
     fn eq(lhs: @(E0, E1), rhs: @(E0, E1)) -> bool {
         let (lhs0, lhs1) = lhs;
@@ -248,12 +237,7 @@ impl TupleSize2PartialEq<
 }
 
 impl TupleSize3PartialEq<
-    E0,
-    E1,
-    E2,
-    impl E0PartialEq: PartialEq<E0>,
-    impl E1PartialEq: PartialEq<E1>,
-    impl E2PartialEq: PartialEq<E2>
+    E0, E1, E2, +PartialEq<E0>, +PartialEq<E1>, +PartialEq<E2>
 > of PartialEq<(E0, E1, E2)> {
     #[inline(always)]
     fn eq(lhs: @(E0, E1, E2), rhs: @(E0, E1, E2)) -> bool {
@@ -268,14 +252,7 @@ impl TupleSize3PartialEq<
 }
 
 impl TupleSize4PartialEq<
-    E0,
-    E1,
-    E2,
-    E3,
-    impl E0PartialEq: PartialEq<E0>,
-    impl E1PartialEq: PartialEq<E1>,
-    impl E2PartialEq: PartialEq<E2>,
-    impl E3PartialEq: PartialEq<E3>
+    E0, E1, E2, E3, +PartialEq<E0>, +PartialEq<E1>, +PartialEq<E2>, +PartialEq<E3>
 > of PartialEq<(E0, E1, E2, E3)> {
     #[inline(always)]
     fn eq(lhs: @(E0, E1, E2, E3), rhs: @(E0, E1, E2, E3)) -> bool {
@@ -296,32 +273,23 @@ impl TupleSize0Default of Default<()> {
     }
 }
 
-impl TupleSize1Default<E0, impl E0Default: Default<E0>> of Default<(E0,)> {
+impl TupleSize1Default<E0, +Default<E0>> of Default<(E0,)> {
     fn default() -> (E0,) {
-        (E0Default::default(),)
+        (Default::default(),)
     }
 }
 
-impl TupleSize2Default<
-    E0, E1, impl E0Default: Default<E0>, impl E0Drop: Drop<E0>, impl E1Default: Default<E1>
-> of Default<(E0, E1)> {
+impl TupleSize2Default<E0, E1, +Default<E0>, +Drop<E0>, +Default<E1>> of Default<(E0, E1)> {
     fn default() -> (E0, E1) {
-        (E0Default::default(), E1Default::default())
+        (Default::default(), Default::default())
     }
 }
 
 impl TupleSize3Default<
-    E0,
-    E1,
-    E2,
-    impl E0Default: Default<E0>,
-    impl E0Drop: Drop<E0>,
-    impl E1Default: Default<E1>,
-    impl E1Drop: Drop<E1>,
-    impl E2Default: Default<E2>
+    E0, E1, E2, +Default<E0>, +Drop<E0>, +Default<E1>, +Drop<E1>, +Default<E2>
 > of Default<(E0, E1, E2)> {
     fn default() -> (E0, E1, E2) {
-        (E0Default::default(), E1Default::default(), E2Default::default())
+        (Default::default(), Default::default(), Default::default())
     }
 }
 
@@ -330,15 +298,15 @@ impl TupleSize4Default<
     E1,
     E2,
     E3,
-    impl E0Default: Default<E0>,
-    impl E0Drop: Drop<E0>,
-    impl E1Default: Default<E1>,
-    impl E1Drop: Drop<E1>,
-    impl E2Default: Default<E2>,
-    impl E2Drop: Drop<E2>,
-    impl E3Default: Default<E3>
+    +Default<E0>,
+    +Drop<E0>,
+    +Default<E1>,
+    +Drop<E1>,
+    +Default<E2>,
+    +Drop<E2>,
+    +Default<E3>
 > of Default<(E0, E1, E2, E3)> {
     fn default() -> (E0, E1, E2, E3) {
-        (E0Default::default(), E1Default::default(), E2Default::default(), E3Default::default())
+        (Default::default(), Default::default(), Default::default(), Default::default())
     }
 }
diff --git a/corelib/src/zeroable.cairo b/corelib/src/zeroable.cairo
index 5f70e85..b22503d 100644
--- a/corelib/src/zeroable.cairo
+++ b/corelib/src/zeroable.cairo
@@ -1,46 +1,55 @@
 // === Zeroable ===
 
-trait Zeroable<T> {
+pub(crate) trait Zeroable<T> {
     /// Returns the additive identity element of Self, 0.
+    #[must_use]
     fn zero() -> T;
     /// Returns whether self is equal to 0, the additive identity element.
+    #[must_use]
     fn is_zero(self: T) -> bool;
     /// Returns whether self is not equal to 0, the additive identity element.
+    #[must_use]
     fn is_non_zero(self: T) -> bool;
 }
 
-impl Felt252Zeroable of Zeroable<felt252> {
-    fn zero() -> felt252 {
-        0
-    }
-    #[inline(always)]
-    fn is_zero(self: felt252) -> bool {
-        self == 0
-    }
-    #[inline(always)]
-    fn is_non_zero(self: felt252) -> bool {
-        !self.is_zero()
+pub(crate) mod zero_based {
+    pub(crate) impl ZeroableImpl<
+        T, impl ZeroImpl: core::num::traits::Zero<T>, +Drop<T>, +Copy<T>
+    > of super::Zeroable<T> {
+        fn zero() -> T {
+            ZeroImpl::zero()
+        }
+        #[inline(always)]
+        fn is_zero(self: T) -> bool {
+            ZeroImpl::is_zero(@self)
+        }
+        #[inline(always)]
+        fn is_non_zero(self: T) -> bool {
+            ZeroImpl::is_non_zero(@self)
+        }
     }
 }
 
+pub(crate) impl Felt252Zeroable = zero_based::ZeroableImpl<felt252>;
+
 // === NonZero ===
 
 #[derive(Copy, Drop)]
-extern type NonZero<T>;
+pub extern type NonZero<T>;
 
-enum IsZeroResult<T> {
+pub(crate) enum IsZeroResult<T> {
     Zero,
     NonZero: NonZero<T>,
 }
 extern fn unwrap_non_zero<T>(a: NonZero<T>) -> T nopanic;
 
-impl NonZeroIntoImpl<T> of Into<NonZero<T>, T> {
+pub(crate) impl NonZeroIntoImpl<T> of Into<NonZero<T>, T> {
     fn into(self: NonZero<T>) -> T nopanic {
         unwrap_non_zero(self)
     }
 }
 
-impl IsZeroResultIntoBool<T, impl TDrop: Drop<T>> of Into<IsZeroResult<T>, bool> {
+impl IsZeroResultIntoBool<T, +Drop<T>> of Into<IsZeroResult<T>, bool> {
     fn into(self: IsZeroResult<T>) -> bool {
         match self {
             IsZeroResult::Zero => true,
@@ -48,3 +57,28 @@ impl IsZeroResultIntoBool<T, impl TDrop: Drop<T>> of Into<IsZeroResult<T>, bool>
         }
     }
 }
+
+impl NonZeroPartialEq<T, +PartialEq<T>, +Copy<T>, +Drop<T>> of PartialEq<NonZero<T>> {
+    #[inline(always)]
+    fn eq(lhs: @NonZero<T>, rhs: @NonZero<T>) -> bool {
+        let lhs: T = (*lhs).into();
+        let rhs: T = (*rhs).into();
+        lhs == rhs
+    }
+    #[inline(always)]
+    fn ne(lhs: @NonZero<T>, rhs: @NonZero<T>) -> bool {
+        let lhs: T = (*lhs).into();
+        let rhs: T = (*rhs).into();
+        lhs != rhs
+    }
+}
+
+impl NonZeroSerde<T, +Serde<T>, +Copy<T>, +Drop<T>, +TryInto<T, NonZero<T>>> of Serde<NonZero<T>> {
+    fn serialize(self: @NonZero<T>, ref output: Array<felt252>) {
+        let value: T = (*self).into();
+        value.serialize(ref output);
+    }
+    fn deserialize(ref serialized: Span<felt252>) -> Option<NonZero<T>> {
+        Serde::<T>::deserialize(ref serialized)?.try_into()
+    }
+}
diff --git a/src/analysis/taint.rs b/src/analysis/taint.rs
index d8e8124..5a61c17 100644
--- a/src/analysis/taint.rs
+++ b/src/analysis/taint.rs
@@ -1,8 +1,5 @@
-use cairo_lang_sierra::{
-    ids::VarId,
-    program::{GenStatement, Statement as SierraStatement},
-};
-use std::collections::{HashMap, HashSet};
+use cairo_lang_sierra::program::{GenStatement, Statement as SierraStatement};
+use fxhash::{FxHashMap, FxHashSet};
 
 /// Wrapper around a VarId
 /// it's used to univocally identify variables
@@ -11,11 +8,11 @@ pub struct WrapperVariable {
     /// The function where the variable appear
     function: String,
     /// The variable's id
-    variable: VarId,
+    variable: u64,
 }
 
 impl WrapperVariable {
-    pub fn new(function: String, variable: VarId) -> Self {
+    pub fn new(function: String, variable: u64) -> Self {
         WrapperVariable { function, variable }
     }
 
@@ -25,8 +22,8 @@ impl WrapperVariable {
     }
 
     /// Return the variable
-    pub fn variable(&self) -> &VarId {
-        &self.variable
+    pub fn variable(&self) -> u64 {
+        self.variable
     }
 }
 
@@ -35,26 +32,26 @@ pub struct Taint {
     /// Source WrapperVariable to set of sink WrapperVariable
     /// e.g. instruction reads variables 3, 4 and has 5 as output
     /// we will add (3, (5)) and (4, (5)); variable 5 is tainted by 3 and 4
-    map: HashMap<WrapperVariable, HashSet<WrapperVariable>>,
+    map: FxHashMap<WrapperVariable, FxHashSet<WrapperVariable>>,
 }
 
 impl Taint {
     pub fn new(instructions: &[SierraStatement], function: String) -> Self {
-        let mut map = HashMap::new();
+        let mut map = FxHashMap::default();
         analyze(&mut map, instructions, function);
 
         Taint { map }
     }
 
     /// Returns variables tainted in a single step by source
-    pub fn single_step_taint(&self, source: &WrapperVariable) -> HashSet<WrapperVariable> {
+    pub fn single_step_taint(&self, source: &WrapperVariable) -> FxHashSet<WrapperVariable> {
         self.map.get(source).cloned().unwrap_or_default()
     }
 
     /// Returns variables tainted in zero or more steps by source
-    pub fn multi_step_taint(&self, source: &WrapperVariable) -> HashSet<WrapperVariable> {
-        let mut result = HashSet::new();
-        let mut update = HashSet::from([source.clone()]);
+    pub fn multi_step_taint(&self, source: &WrapperVariable) -> FxHashSet<WrapperVariable> {
+        let mut result = FxHashSet::default();
+        let mut update = FxHashSet::from_iter([source.clone()]);
         while !update.is_subset(&result) {
             result.extend(update.iter().cloned());
             update = update
@@ -69,7 +66,7 @@ impl Taint {
     pub fn taints_any_sinks_variable(
         &self,
         source: &WrapperVariable,
-        sinks: &HashSet<WrapperVariable>,
+        sinks: &FxHashSet<WrapperVariable>,
     ) -> Vec<WrapperVariable> {
         self.multi_step_taint(source)
             .into_iter()
@@ -81,7 +78,7 @@ impl Taint {
     pub fn taints_any_sinks(
         &self,
         source: &WrapperVariable,
-        sinks: &HashSet<WrapperVariable>,
+        sinks: &FxHashSet<WrapperVariable>,
     ) -> bool {
         self.multi_step_taint(source)
             .iter()
@@ -91,7 +88,7 @@ impl Taint {
     /// Returns the sources that taint the sink
     pub fn taints_any_sources_variable(
         &self,
-        sources: &HashSet<WrapperVariable>,
+        sources: &FxHashSet<WrapperVariable>,
         sink: &WrapperVariable,
     ) -> Vec<WrapperVariable> {
         sources
@@ -104,7 +101,7 @@ impl Taint {
     /// Returns true if the sink is tainted by any source
     pub fn taints_any_sources(
         &self,
-        sources: &HashSet<WrapperVariable>,
+        sources: &FxHashSet<WrapperVariable>,
         sink: &WrapperVariable,
     ) -> bool {
         sources
@@ -121,7 +118,7 @@ impl Taint {
 
 /// Analyze each instruction in the current function and populate the taint map
 fn analyze(
-    map: &mut HashMap<WrapperVariable, HashSet<WrapperVariable>>,
+    map: &mut FxHashMap<WrapperVariable, FxHashSet<WrapperVariable>>,
     instructions: &[SierraStatement],
     function: String,
 ) {
@@ -140,12 +137,12 @@ fn analyze(
                     let sinks = map
                         .entry(WrapperVariable {
                             function: function.clone(),
-                            variable: source.clone(),
+                            variable: source.id,
                         })
                         .or_default();
                     sinks.insert(WrapperVariable {
                         function: function.clone(),
-                        variable: sink.clone(),
+                        variable: sink.id,
                     });
                 }
             }
diff --git a/src/compilation/cairo_project.rs b/src/compilation/cairo_project.rs
index c8a3dcf..99153dd 100644
--- a/src/compilation/cairo_project.rs
+++ b/src/compilation/cairo_project.rs
@@ -1,8 +1,7 @@
-use anyhow::{anyhow, bail, Context, Result};
+use anyhow::{anyhow, bail, Result};
 use std::env;
 use std::process;
 use std::process::Output;
-use std::sync::Arc;
 
 use super::ProgramCompiled;
 use crate::compilation::utils::felt252_serde::sierra_from_felt252s;
@@ -12,14 +11,11 @@ use cairo_lang_compiler::db::RootDatabase;
 use cairo_lang_compiler::project::{setup_project, ProjectConfig, ProjectConfigContent};
 use cairo_lang_compiler::CompilerConfig;
 use cairo_lang_filesystem::ids::Directory;
-use cairo_lang_sierra_generator::db::SierraGenGroup;
-use cairo_lang_sierra_generator::replace_ids::{replace_sierra_ids_in_program, SierraIdReplacer};
-use cairo_lang_starknet::abi::{AbiBuilder, Contract};
+use cairo_lang_sierra_generator::replace_ids::SierraIdReplacer;
 use cairo_lang_starknet::compiler_version::current_compiler_version_id;
 use cairo_lang_starknet::contract::find_contracts;
-use cairo_lang_starknet::contract_class::ContractClass;
-use cairo_lang_starknet::inline_macros::selector::SelectorMacro;
-use cairo_lang_starknet::plugin::StarkNetPlugin;
+use cairo_lang_starknet::contract_class::{compile_prepared_db, ContractClass};
+use cairo_lang_starknet::starknet_plugin_suite;
 use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
 
 pub fn compile(opts: CoreOpts) -> Result<Vec<ProgramCompiled>> {
@@ -60,41 +56,49 @@ pub fn compile(opts: CoreOpts) -> Result<Vec<ProgramCompiled>> {
         base_path: "".into(),
         content: ProjectConfigContent {
             crate_roots: OrderedHashMap::default(),
+            crates_config: Default::default(),
         },
     };
 
     let mut db = RootDatabase::builder()
         .with_project_config(project_config)
-        .with_macro_plugin(Arc::new(StarkNetPlugin::default()))
-        .with_inline_macro_plugin(SelectorMacro::NAME, Arc::new(SelectorMacro))
+        .with_plugin_suite(starknet_plugin_suite())
         .build()?;
 
-    let mut compiler_config = CompilerConfig::default();
+    let compiler_config = CompilerConfig {
+        replace_ids: true,
+        ..Default::default()
+    };
 
     let main_crate_ids = setup_project(&mut db, &opts.target)?;
-    compiler_config.diagnostics_reporter.ensure(&db)?;
 
     let contracts = find_contracts(&db, &main_crate_ids);
     if contracts.is_empty() {
         bail!("Contract not found.");
     }
 
-    let mut abi: Contract = Default::default();
-    contracts.iter().for_each(|c| {
-        abi.items.extend(
-            AbiBuilder::submodule_as_contract_abi(&db, c.submodule_id)
-                .expect("Error when getting the ABI.")
-                .items,
-        )
-    });
-
-    let sierra = db
-        .get_sierra_program(main_crate_ids)
-        .ok()
-        .context("Compilation failed without any diagnostics.")?;
-    let sierra = replace_sierra_ids_in_program(&db, &sierra);
-
-    Ok(vec![ProgramCompiled { sierra, abi }])
+    let mut contracts_arg = vec![];
+    contracts.iter().for_each(|c| contracts_arg.push(c));
+
+    let contract_classes = compile_prepared_db(&db, &contracts_arg, compiler_config)
+        .expect("Error when compiling contracts.");
+
+    let mut programs_compiled: Vec<ProgramCompiled> = vec![];
+
+    for contract_class in contract_classes {
+        let debug_info = contract_class.sierra_program_debug_info.unwrap();
+        let program = sierra_from_felt252s(&contract_class.sierra_program)
+            .unwrap()
+            .2;
+        let program = SierraProgramDebugReplacer { debug_info }.apply(&program);
+
+        programs_compiled.push(ProgramCompiled {
+            sierra: program,
+            abi: contract_class.abi.unwrap(),
+        });
+    }
+
+    Ok(programs_compiled)
 }
 
 fn local_compiler(opts: CoreOpts) -> Result<Vec<ProgramCompiled>> {
diff --git a/src/compilation/mod.rs b/src/compilation/mod.rs
index dbf17af..f420e97 100644
--- a/src/compilation/mod.rs
+++ b/src/compilation/mod.rs
@@ -9,7 +9,7 @@ use crate::core::core_unit::CoreOpts;
 mod cairo_project;
 mod scarb;
 mod standard;
-mod utils;
+pub mod utils;
 
 pub struct ProgramCompiled {
     pub sierra: Program,
diff --git a/src/compilation/scarb.rs b/src/compilation/scarb.rs
index d949a36..a551a75 100644
--- a/src/compilation/scarb.rs
+++ b/src/compilation/scarb.rs
@@ -19,6 +19,7 @@ pub fn compile(opts: CoreOpts) -> Result<Vec<ProgramCompiled>> {
     let output = process::Command::new("scarb")
         .current_dir(opts.target.as_path())
         .arg("build")
+        .arg("--workspace")
         .output()?;
 
     if !output.status.success() {
@@ -61,7 +62,13 @@ pub fn compile(opts: CoreOpts) -> Result<Vec<ProgramCompiled>> {
     for sierra_file in sierra_files_path {
         let contents =
             fs::read_to_string(sierra_file.as_path()).expect("Failed to read a sierra file");
-        let contract_class: ContractClass = serde_json::from_str(&contents).unwrap();
+        // In some cases a .sierra is made even for newer scarb version which does not have a contract class
+        // and it is not needed for us so if we get an error we skip the file
+        let contract_class: ContractClass = if let Ok(c) = serde_json::from_str(&contents) {
+            c
+        } else {
+            continue;
+        };
         let debug_info;
 
         if contract_class.sierra_program_debug_info.is_none() {
diff --git a/src/compilation/standard.rs b/src/compilation/standard.rs
index a3343a6..5fce7f2 100644
--- a/src/compilation/standard.rs
+++ b/src/compilation/standard.rs
@@ -1,20 +1,16 @@
-use anyhow::{anyhow, bail, Context, Result};
+use anyhow::{anyhow, bail, Result};
 use std::env;
 use std::process;
-use std::sync::Arc;
 
 use cairo_lang_compiler::db::RootDatabase;
 use cairo_lang_compiler::project::{setup_project, ProjectConfig, ProjectConfigContent};
 use cairo_lang_compiler::CompilerConfig;
 use cairo_lang_filesystem::ids::Directory;
-use cairo_lang_sierra_generator::db::SierraGenGroup;
-use cairo_lang_sierra_generator::replace_ids::{replace_sierra_ids_in_program, SierraIdReplacer};
-use cairo_lang_starknet::abi::{AbiBuilder, Contract};
+use cairo_lang_sierra_generator::replace_ids::SierraIdReplacer;
 use cairo_lang_starknet::compiler_version::current_compiler_version_id;
 use cairo_lang_starknet::contract::find_contracts;
-use cairo_lang_starknet::contract_class::ContractClass;
-use cairo_lang_starknet::inline_macros::selector::SelectorMacro;
-use cairo_lang_starknet::plugin::StarkNetPlugin;
+use cairo_lang_starknet::contract_class::{compile_prepared_db, ContractClass};
+use cairo_lang_starknet::starknet_plugin_suite;
 use cairo_lang_utils::ordered_hash_map::OrderedHashMap;
 
 use super::ProgramCompiled;
@@ -68,41 +64,49 @@ pub fn compile(opts: CoreOpts) -> Result<Vec<ProgramCompiled>> {
         base_path: "".into(),
         content: ProjectConfigContent {
             crate_roots: OrderedHashMap::default(),
+            crates_config: Default::default(),
         },
     };
 
     let mut db = RootDatabase::builder()
         .with_project_config(project_config)
-        .with_macro_plugin(Arc::new(StarkNetPlugin::default()))
-        .with_inline_macro_plugin(SelectorMacro::NAME, Arc::new(SelectorMacro))
+        .with_plugin_suite(starknet_plugin_suite())
         .build()?;
 
-    let mut compiler_config = CompilerConfig::default();
+    let compiler_config = CompilerConfig {
+        replace_ids: true,
+        ..Default::default()
+    };
 
     let main_crate_ids = setup_project(&mut db, &opts.target)?;
-    compiler_config.diagnostics_reporter.ensure(&db)?;
 
     let contracts = find_contracts(&db, &main_crate_ids);
     if contracts.is_empty() {
         bail!("Contract not found.");
     }
 
-    let mut abi: Contract = Default::default();
-    contracts.iter().for_each(|c| {
-        abi.items.extend(
-            AbiBuilder::submodule_as_contract_abi(&db, c.submodule_id)
-                .expect("Error when getting the ABI.")
-                .items,
-        )
-    });
-
-    let sierra = db
-        .get_sierra_program(main_crate_ids)
-        .ok()
-        .context("Compilation failed without any diagnostics.")?;
-    let sierra = replace_sierra_ids_in_program(&db, &sierra);
-
-    Ok(vec![ProgramCompiled { sierra, abi }])
+    let mut contracts_arg = vec![];
+    contracts.iter().for_each(|c| contracts_arg.push(c));
+
+    let contract_classes = compile_prepared_db(&db, &contracts_arg, compiler_config)
+        .expect("Error when compiling contracts.");
+
+    let mut programs_compiled: Vec<ProgramCompiled> = vec![];
+
+    for contract_class in contract_classes {
+        let debug_info = contract_class.sierra_program_debug_info.unwrap();
+        let program = sierra_from_felt252s(&contract_class.sierra_program)
+            .unwrap()
+            .2;
+        let program = SierraProgramDebugReplacer { debug_info }.apply(&program);
+
+        programs_compiled.push(ProgramCompiled {
+            sierra: program,
+            abi: contract_class.abi.unwrap(),
+        });
+    }
+
+    Ok(programs_compiled)
 }
 
 fn local_compiler(opts: CoreOpts, single_file_flag: bool) -> Result<Vec<ProgramCompiled>> {
diff --git a/src/core/compilation_unit.rs b/src/core/compilation_unit.rs
index 157d1c7..c234be8 100644
--- a/src/core/compilation_unit.rs
+++ b/src/core/compilation_unit.rs
@@ -1,5 +1,3 @@
-use std::collections::{HashMap, HashSet};
-
 use super::function::{Function, Type};
 use crate::analysis::taint::Taint;
 use crate::analysis::taint::WrapperVariable;
@@ -13,6 +11,8 @@ use cairo_lang_starknet::abi::{
     Contract, Item::Function as AbiFunction, Item::Interface as AbiInterface,
     Item::L1Handler as AbiL1Handler,
 };
+use fxhash::FxHashSet;
+use std::collections::{HashMap, HashSet};
 
 pub struct CompilationUnit {
     /// The compiled sierra program
@@ -85,18 +85,15 @@ impl CompilationUnit {
 
     /// Return true if the variable is tainted i.e. user inputs can control it in some way
     pub fn is_tainted(&self, function_name: String, variable: VarId) -> bool {
-        let wrapped_variable = WrapperVariable::new(function_name, variable);
-        let mut parameters = HashSet::new();
+        let wrapped_variable = WrapperVariable::new(function_name, variable.id);
+        let mut parameters = FxHashSet::default();
         for external_function in self
             .functions
             .iter()
             .filter(|f| matches!(f.ty(), Type::External | Type::L1Handler | Type::View))
         {
             for param in external_function.params().skip(1) {
-                parameters.insert(WrapperVariable::new(
-                    external_function.name(),
-                    param.id.clone(),
-                ));
+                parameters.insert(WrapperVariable::new(external_function.name(), param.id.id));
             }
         }
         // Get the taint for the function where the variable appear
@@ -132,7 +129,7 @@ impl CompilationUnit {
             let full_name = f.id.to_string();
             if full_name.contains("::__wrapper_") {
                 // This case happens for cairo >= 2.2.0
-                let function_name = full_name.replace("__wrapper_", "");
+                let function_name = full_name.replace("__wrapper__", "").replace("__", "::");
                 if function_name.ends_with("::constructor") {
                     constructors.insert(function_name);
                 } else {
@@ -175,7 +172,7 @@ impl CompilationUnit {
                 // External function, we need to check in the abi if it's view or external
                 let function_name = full_name.rsplit_once("::").unwrap().1;
 
-                for item in self.abi.items.iter() {
+                for item in self.abi.clone() {
                     match item {
                         AbiFunction(function) => {
                             if function.name == function_name {
@@ -247,7 +244,7 @@ impl CompilationUnit {
             } else {
                 // Event or private function
                 // Could be an event emission or a private function in the contract's module
-                if full_name.contains("::ContractStateEventEmitter::emit::") {
+                if full_name.contains("::emit::") {
                     f.set_ty(Type::Event);
                 } else if full_name.ends_with(']') {
                     f.set_ty(Type::Loop);
@@ -330,7 +327,7 @@ impl CompilationUnit {
     /// Propagate the taints from external/l1_handler functions to private functions
     fn propagate_taints(&mut self) {
         // Collect the arguments of all the external/l1_handler functions
-        let mut arguments_external_functions: HashSet<WrapperVariable> = HashSet::new();
+        let mut arguments_external_functions: FxHashSet<WrapperVariable> = FxHashSet::default();
         for function in self
             .functions
             .iter()
@@ -338,7 +335,7 @@ impl CompilationUnit {
         {
             for param in function.params() {
                 arguments_external_functions
-                    .insert(WrapperVariable::new(function.name(), param.id.clone()));
+                    .insert(WrapperVariable::new(function.name(), param.id.id));
             }
         }
 
@@ -348,17 +345,35 @@ impl CompilationUnit {
         }
 
         let mut changed = true;
-        // Iterate external, l1_handler, private functions and propagate the taints to each private function they call
+        // Iterate external, l1_handler, private, loop functions and propagate the taints to each private function they call
         // until a fixpoint when no new informations were propagated
-        while changed {
-            changed = false;
-
-            for calling_function in self.functions.iter().filter(|f| {
+        let mut functions_to_check: HashSet<String> = self
+            .functions
+            .iter()
+            .filter(|f| {
                 matches!(
                     f.ty(),
                     Type::External | Type::L1Handler | Type::Private | Type::Loop
                 )
+            })
+            .map(|f| f.name())
+            .collect();
+
+        // We need to use changed and not !functions_to_check.is_empty() because it can contain functions that are never removed
+        // such as Core and it would be an infinite loop
+        while changed {
+            changed = false;
+
+            let functions_to_check_copy = functions_to_check.clone();
+            for calling_function in self.functions.iter().filter(|f| {
+                functions_to_check_copy.contains(&f.name())
+                    && matches!(
+                        f.ty(),
+                        Type::External | Type::L1Handler | Type::Private | Type::Loop
+                    )
             }) {
+                functions_to_check.remove(&calling_function.name());
+
                 for function_call in calling_function
                     .private_functions_calls()
                     .chain(calling_function.loop_functions_calls())
@@ -377,12 +392,10 @@ impl CompilationUnit {
                             let external_taint = taint_copy.get(&calling_function.name()).unwrap();
 
                             // Variables used as arguments in the call to the private function
-                            let function_called_args: HashSet<WrapperVariable> = invoc
+                            let function_called_args: FxHashSet<WrapperVariable> = invoc
                                 .args
                                 .iter()
-                                .map(|arg| {
-                                    WrapperVariable::new(calling_function.name(), arg.clone())
-                                })
+                                .map(|arg| WrapperVariable::new(calling_function.name(), arg.id))
                                 .collect();
 
                             // Calling function's parameters
@@ -401,10 +414,7 @@ impl CompilationUnit {
                                 }
                                 // Check if the arguments used to call the private function are tainted by the calling function's parameters
                                 for sink in external_taint.taints_any_sinks_variable(
-                                    &WrapperVariable::new(
-                                        calling_function.name(),
-                                        param.id.clone(),
-                                    ),
+                                    &WrapperVariable::new(calling_function.name(), param.id.id),
                                     &function_called_args,
                                 ) {
                                     // If the sink is tainted by some parameters of external functions
@@ -424,14 +434,24 @@ impl CompilationUnit {
                                         let private_taint =
                                             self.taint.get_mut(&function_called_name).unwrap();
 
-                                        // We convert the id to be the private function's formal parameter id and not the actual parameter id
-                                        let sink_converted = WrapperVariable::new(
-                                            function_called_name,
-                                            VarId::new(sink.variable().id - invoc.args[0].id),
-                                        );
-                                        // Add the source i.e. the variable of the external function
-                                        if private_taint.add_taint(source, sink_converted) {
-                                            changed = true;
+                                        // The VarId used when calling a function may not have the IDs increasing sequentially
+                                        // so to convert the ID we have to iterate the arguments and use the index where we find
+                                        // our sink VarId
+                                        for (i, var) in invoc.args.iter().enumerate() {
+                                            if var.id == sink.variable() {
+                                                // We convert the id to be the private function's formal parameter id and not the actual parameter id
+                                                let sink_converted = WrapperVariable::new(
+                                                    function_called_name.clone(),
+                                                    i.try_into().unwrap(),
+                                                );
+
+                                                // Add the source i.e. the variable of the external function
+                                                if private_taint.add_taint(source, sink_converted) {
+                                                    functions_to_check.insert(function_called_name);
+                                                    changed = true;
+                                                }
+                                                break;
+                                            }
                                         }
                                     }
                                 }
diff --git a/src/core/core_unit.rs b/src/core/core_unit.rs
index 1f73cce..e895f48 100644
--- a/src/core/core_unit.rs
+++ b/src/core/core_unit.rs
@@ -1,11 +1,10 @@
+use crate::compilation::compile;
+use crate::core::compilation_unit::CompilationUnit;
 use anyhow::Result;
-use std::path::PathBuf;
-
 use cairo_lang_sierra::extensions::core::{CoreLibfunc, CoreType};
 use cairo_lang_sierra::program_registry::ProgramRegistry;
-
-use crate::compilation::compile;
-use crate::core::compilation_unit::CompilationUnit;
+use rayon::prelude::*;
+use std::path::PathBuf;
 
 pub struct CoreOpts {
     pub target: PathBuf,
@@ -21,7 +20,7 @@ impl CoreUnit {
     pub fn new(opts: CoreOpts) -> Result<Self> {
         let program_compiled = compile(opts)?;
         let compilation_units = program_compiled
-            .iter()
+            .par_iter()
             .map(|p| {
                 let mut compilation_unit = CompilationUnit::new(
                     p.sierra.clone(),
@@ -32,7 +31,6 @@ impl CoreUnit {
                 compilation_unit
             })
             .collect();
-
         Ok(CoreUnit { compilation_units })
     }
 
diff --git a/src/detectors/array_use_after_pop_front.rs b/src/detectors/array_use_after_pop_front.rs
index c7edf30..52d213f 100644
--- a/src/detectors/array_use_after_pop_front.rs
+++ b/src/detectors/array_use_after_pop_front.rs
@@ -1,5 +1,3 @@
-use std::collections::HashSet;
-
 use super::detector::{Confidence, Detector, Impact, Result};
 use crate::analysis::taint::WrapperVariable;
 use crate::core::compilation_unit::CompilationUnit;
@@ -8,6 +6,8 @@ use crate::core::function::{Function, Type};
 use cairo_lang_sierra::extensions::array::ArrayConcreteLibfunc;
 use cairo_lang_sierra::extensions::core::{CoreConcreteLibfunc, CoreTypeConcrete};
 use cairo_lang_sierra::program::{GenStatement, Statement as SierraStatement};
+use fxhash::FxHashSet;
+use std::collections::HashSet;
 
 #[derive(Default)]
 pub struct ArrayUseAfterPopFront {}
@@ -50,10 +50,7 @@ impl Detector for ArrayUseAfterPopFront {
                                 CoreConcreteLibfunc::Array(ArrayConcreteLibfunc::PopFront(_)) => {
                                     Some((
                                         index,
-                                        WrapperVariable::new(
-                                            function.name(),
-                                            invoc.args[0].clone(),
-                                        ),
+                                        WrapperVariable::new(function.name(), invoc.args[0].id),
                                     ))
                                 }
                                 _ => None,
@@ -78,7 +75,7 @@ impl Detector for ArrayUseAfterPopFront {
                 if !bad_array_used.is_empty() {
                     let array_ids = bad_array_used
                         .iter()
-                        .map(|f| f.1.variable().id)
+                        .map(|f| f.1.variable())
                         .collect::<Vec<u64>>();
                     let message = match array_ids.len() {
                         1 => format!(
@@ -163,8 +160,8 @@ impl ArrayUseAfterPopFront {
 
                 match libfunc {
                     CoreConcreteLibfunc::Array(ArrayConcreteLibfunc::Append(_)) => {
-                        let mut sinks = HashSet::new();
-                        sinks.insert(WrapperVariable::new(function.name(), invoc.args[0].clone()));
+                        let mut sinks = FxHashSet::default();
+                        sinks.insert(WrapperVariable::new(function.name(), invoc.args[0].id));
 
                         taint.taints_any_sinks(bad_array, &sinks)
                     }
@@ -192,10 +189,10 @@ impl ArrayUseAfterPopFront {
                     .expect("Library function not found in the registry");
 
                 if let CoreConcreteLibfunc::FunctionCall(_) = lib_func {
-                    let sinks: HashSet<WrapperVariable> = invoc
+                    let sinks: FxHashSet<WrapperVariable> = invoc
                         .args
                         .iter()
-                        .map(|v| WrapperVariable::new(function.name(), v.clone()))
+                        .map(|v| WrapperVariable::new(function.name(), v.id))
                         .collect();
 
                     return taint.taints_any_sinks(bad_array, &sinks);
@@ -271,7 +268,7 @@ impl ArrayUseAfterPopFront {
                                         .map(|i| {
                                             WrapperVariable::new(
                                                 maybe_caller.name(),
-                                                invoc.branches[0].results[*i].clone(),
+                                                invoc.branches[0].results[*i].id,
                                             )
                                         })
                                         .collect();
@@ -325,16 +322,16 @@ impl ArrayUseAfterPopFront {
             return false;
         }
 
-        // Not sure if it is required because taint analysis adds all the arugments as
+        // Not sure if it is required because taint analysis adds all the arguments as
         // tainters of the all the return values.
         let returned_bad_arrays: Vec<WrapperVariable> = function
             .get_statements()
             .iter()
             .flat_map(|s| {
                 if let GenStatement::Return(return_vars) = s {
-                    let sinks: HashSet<WrapperVariable> = return_vars
+                    let sinks: FxHashSet<WrapperVariable> = return_vars
                         .iter()
-                        .map(|v| WrapperVariable::new(function.name(), v.clone()))
+                        .map(|v| WrapperVariable::new(function.name(), v.id))
                         .collect();
 
                     return taint.taints_any_sinks_variable(bad_array, &sinks);
diff --git a/src/detectors/felt252_overflow.rs b/src/detectors/felt252_overflow.rs
index 7152ebb..5822210 100644
--- a/src/detectors/felt252_overflow.rs
+++ b/src/detectors/felt252_overflow.rs
@@ -5,9 +5,9 @@ use cairo_lang_sierra::extensions::felt252::Felt252BinaryOperationConcrete;
 use cairo_lang_sierra::extensions::felt252::Felt252BinaryOperator;
 use cairo_lang_sierra::extensions::{core::CoreConcreteLibfunc, felt252::Felt252Concrete};
 use cairo_lang_sierra::ids::VarId;
-use cairo_lang_sierra::program::GenInvocation;
 use cairo_lang_sierra::program::Statement as SierraStatement;
 use cairo_lang_sierra::program::StatementIdx;
+use cairo_lang_sierra::program::{GenInvocation, GenStatement};
 use std::collections::HashSet;
 
 #[derive(Default)]
@@ -157,35 +157,17 @@ impl Felt252Overflow {
             Felt252BinaryOperator::Sub => {
                 let ret_value = &invoc.branches[0].results[0];
 
-                // Look two instructions in advance
-
-                if let Some(SierraStatement::Invocation(sub_statement)) = statements.get(idx + 2) {
-                    // Check if felt252_is_zero uses return param of sub instruction
-
-                    let libfunc_sub = compilation_unit
-                        .registry()
-                        .get_libfunc(&sub_statement.libfunc_id)
-                        .expect("Library function not found in the registry");
-                    if let CoreConcreteLibfunc::Felt252(Felt252Concrete::IsZero(_)) = libfunc_sub {
-                        let user_params = &sub_statement.args;
-                        if !user_params.contains(ret_value) {
-                            self.check_felt252_tainted(
-                                results,
-                                compilation_unit,
-                                libfunc,
-                                &invoc.args,
-                                name,
-                            );
-                        }
-                    } else {
-                        self.check_felt252_tainted(
-                            results,
-                            compilation_unit,
-                            libfunc,
-                            &invoc.args,
-                            name,
-                        )
-                    }
+                // Look two and three instructions in advance for an is_zero op
+                if self.check_is_zero(statements.get(idx + 2), compilation_unit, ret_value)
+                    && self.check_is_zero(statements.get(idx + 3), compilation_unit, ret_value)
+                {
+                    self.check_felt252_tainted(
+                        results,
+                        compilation_unit,
+                        libfunc,
+                        &invoc.args,
+                        name,
+                    );
                 }
             }
             _ => {
@@ -193,4 +175,31 @@ impl Felt252Overflow {
             }
         }
     }
+
+    // Return true if there is not an is_zero op or if it does not use the ret_value
+    // which means it is a real sub operation not used in an if
+    fn check_is_zero(
+        &self,
+        statement: Option<&GenStatement<StatementIdx>>,
+        compilation_unit: &CompilationUnit,
+        ret_value: &VarId,
+    ) -> bool {
+        if let Some(SierraStatement::Invocation(sub_statement)) = statement {
+            // Check if felt252_is_zero uses return param of sub instruction
+            let libfunc_sub = compilation_unit
+                .registry()
+                .get_libfunc(&sub_statement.libfunc_id)
+                .expect("Library function not found in the registry");
+            if let CoreConcreteLibfunc::Felt252(Felt252Concrete::IsZero(_)) = libfunc_sub {
+                let user_params = &sub_statement.args;
+                if !user_params.contains(ret_value) {
+                    return true;
+                }
+                return false;
+            } else {
+                return true;
+            }
+        }
+        true
+    }
 }
diff --git a/src/detectors/read_only_reentrancy.rs b/src/detectors/read_only_reentrancy.rs
index d19ec66..1d717d1 100644
--- a/src/detectors/read_only_reentrancy.rs
+++ b/src/detectors/read_only_reentrancy.rs
@@ -45,7 +45,7 @@ impl Detector for ReadOnlyReentrancy {
                         .unwrap()
                         .0
                         .to_string();
-                    let functions_name = vars_read.entry(var_read).or_insert(HashSet::new());
+                    let functions_name = vars_read.entry(var_read).or_default();
                     functions_name.insert(f.name());
                 }
             }
diff --git a/src/detectors/unchecked_l1_handler_from.rs b/src/detectors/unchecked_l1_handler_from.rs
index c34de6a..501ff74 100644
--- a/src/detectors/unchecked_l1_handler_from.rs
+++ b/src/detectors/unchecked_l1_handler_from.rs
@@ -1,5 +1,3 @@
-use std::collections::HashSet;
-
 use super::detector::{Confidence, Detector, Impact, Result};
 use crate::analysis::taint::WrapperVariable;
 use crate::core::compilation_unit::CompilationUnit;
@@ -8,6 +6,8 @@ use crate::core::function::{Function, Type};
 use cairo_lang_sierra::extensions::{core::CoreConcreteLibfunc, felt252::Felt252Concrete};
 use cairo_lang_sierra::ids::VarId;
 use cairo_lang_sierra::program::{GenStatement, Statement as SierraStatement};
+use fxhash::FxHashSet;
+use std::collections::HashSet;
 
 #[derive(Default)]
 pub struct UncheckedL1HandlerFrom {}
@@ -42,8 +42,8 @@ impl Detector for UncheckedL1HandlerFrom {
             for f in l1_handler_funcs {
                 let from_address =
                     f.params().map(|p| p.id.clone()).collect::<Vec<VarId>>()[1].clone();
-                let mut sources = HashSet::new();
-                sources.insert(WrapperVariable::new(f.name(), from_address));
+                let mut sources = FxHashSet::default();
+                sources.insert(WrapperVariable::new(f.name(), from_address.id));
 
                 // Used to avoid infinite recursion in case of recursive private function calls
                 let mut checked_private_functions = HashSet::new();
@@ -78,7 +78,7 @@ impl Detector for UncheckedL1HandlerFrom {
 impl UncheckedL1HandlerFrom {
     fn is_from_checked_in_function(
         &self,
-        from_tainted_args: &HashSet<WrapperVariable>,
+        from_tainted_args: &FxHashSet<WrapperVariable>,
         compilation_unit: &CompilationUnit,
         function: &Function,
         checked_private_functions: &mut HashSet<String>,
@@ -98,7 +98,7 @@ impl UncheckedL1HandlerFrom {
 
                 match libfunc {
                     CoreConcreteLibfunc::Felt252(Felt252Concrete::IsZero(_)) => self
-                        .is_felt252_is_zero_arg_taintaed_by_from_address(
+                        .is_felt252_is_zero_arg_tainted_by_from_address(
                             from_tainted_args,
                             invoc.args.clone(),
                             compilation_unit,
@@ -126,19 +126,19 @@ impl UncheckedL1HandlerFrom {
 
                         let taint = compilation_unit.get_taint(&function.name()).unwrap();
 
-                        let sinks: HashSet<WrapperVariable> = invoc
+                        let sinks: FxHashSet<WrapperVariable> = invoc
                             .args
                             .iter()
-                            .map(|v| WrapperVariable::new(function.name(), v.clone()))
+                            .map(|v| WrapperVariable::new(function.name(), v.id))
                             .collect();
 
-                        let from_tainted_args: HashSet<WrapperVariable> = from_tainted_args
+                        let from_tainted_args: FxHashSet<WrapperVariable> = from_tainted_args
                             .iter()
                             .flat_map(|source| taint.taints_any_sinks_variable(source, &sinks))
                             .map(|sink| {
                                 WrapperVariable::new(
                                     private_function.name(),
-                                    VarId::new(sink.variable().id - invoc.args[0].id),
+                                    sink.variable() - invoc.args[0].id,
                                 )
                             })
                             .collect();
@@ -158,14 +158,14 @@ impl UncheckedL1HandlerFrom {
         from_checked_in_private_functions
     }
 
-    fn is_felt252_is_zero_arg_taintaed_by_from_address(
+    fn is_felt252_is_zero_arg_tainted_by_from_address(
         &self,
-        sources: &HashSet<WrapperVariable>,
+        sources: &FxHashSet<WrapperVariable>,
         felt252_is_zero_args: Vec<VarId>,
         compilation_unit: &CompilationUnit,
         function_name: &str,
     ) -> bool {
-        let sink = WrapperVariable::new(function_name.to_string(), felt252_is_zero_args[0].clone());
+        let sink = WrapperVariable::new(function_name.to_string(), felt252_is_zero_args[0].id);
         let taint = compilation_unit.get_taint(function_name).unwrap();
         // returns true If the felt252_is_zero arguments are tainted by the from_address
         taint.taints_any_sources(sources, &sink)
diff --git a/tests/detectors/array_use_after_pop_front.cairo b/tests/detectors/array_use_after_pop_front.cairo
index 19264f5..7612a0f 100644
--- a/tests/detectors/array_use_after_pop_front.cairo
+++ b/tests/detectors/array_use_after_pop_front.cairo
@@ -32,7 +32,7 @@ mod ArrayUseAfterPopFront {
         let mut arr = ArrayTrait::<u128>::new();
         arr.append(1);
 
-        let b = arr.pop_front();
+        let _b = arr.pop_front();
         self.emit(ArrayEvent{ arr});
     }
 
@@ -42,7 +42,7 @@ mod ArrayUseAfterPopFront {
         arr.append(1);
 
         match arr.pop_front() {
-            Option::Some(val) => {
+            Option::Some(_val) => {
                 self.emit(ArrayEvent{ arr });
                 ()
             },
@@ -57,7 +57,7 @@ mod ArrayUseAfterPopFront {
 
         loop {
             match arr.pop_front() {
-                Option::Some(val) => (),
+                Option::Some(_val) => (),
                 Option::None(_) => {
                     break ();
                 }
@@ -72,7 +72,7 @@ mod ArrayUseAfterPopFront {
         let mut arr = ArrayTrait::<u128>::new();
         arr.append(1);
 
-        let b = arr.pop_front();
+        let _b = arr.pop_front();
         return arr;
     }
 
@@ -81,7 +81,7 @@ mod ArrayUseAfterPopFront {
         let mut arr = ArrayTrait::<u128>::new();
         arr.append(1);
 
-        let b = arr.pop_front();
+        let _b = arr.pop_front();
         return IAnotherContractLibraryDispatcher { class_hash: starknet::class_hash_const::<0>() }.foo(arr);
     }
 
@@ -90,7 +90,7 @@ mod ArrayUseAfterPopFront {
         let mut arr = ArrayTrait::<u128>::new();
         arr.append(1);
 
-        let b = arr.pop_front();
+        let _b = arr.pop_front();
         return IAnotherContractDispatcher { contract_address: starknet::contract_address_const::<0>() }.foo(arr);
     }
 
@@ -99,13 +99,13 @@ mod ArrayUseAfterPopFront {
         let mut arr = ArrayTrait::<u128>::new();
         arr.append(1);
 
-        let b = arr.pop_front();
+        let _b = arr.pop_front();
         self.emit(ArrayEvent{ arr });
 
         let mut arr1 = ArrayTrait::<u128>::new();
         arr1.append(1);
 
-        let b1 = arr1.pop_front();
+        let _b1 = arr1.pop_front();
         self.emit(ArrayEvent{ arr: arr1 });
     }
 
@@ -114,7 +114,7 @@ mod ArrayUseAfterPopFront {
         let mut arr = ArrayTrait::<u128>::new();
         arr.append(1);
 
-        arr.pop_front();
+        let _a = arr.pop_front();
     }
 
     #[external(v0)]
@@ -124,7 +124,7 @@ mod ArrayUseAfterPopFront {
 
         loop {
             match arr.pop_front() {
-                Option::Some(val) => (),
+                Option::Some(_val) => (),
                 Option::None(_) => {
                     break ();
                 }
diff --git a/tests/detectors/controlled_library_call.cairo b/tests/detectors/controlled_library_call.cairo
index ebd6329..e394114 100644
--- a/tests/detectors/controlled_library_call.cairo
+++ b/tests/detectors/controlled_library_call.cairo
@@ -14,11 +14,12 @@ mod TestContract {
 
     #[external(v0)]
     fn bad1(ref self: ContractState, class_hash: ClassHash) -> u128 {
-        IAnotherContractLibraryDispatcher { class_hash: class_hash }.foo(2_u128)
+       IAnotherContractLibraryDispatcher { class_hash: class_hash }.foo(2_u128)
     }
 
     #[external(v0)]
     fn bad2(ref self: ContractState, class_hash: ClassHash) -> u128 {
+        let _a = 2_u128; // Need this otherwise the compiler inline this function in the wrapper
         internal_lib_call(class_hash)
     }
 
@@ -26,6 +27,17 @@ mod TestContract {
         IAnotherContractLibraryDispatcher { class_hash: class_hash }.foo(2_u128)
     }
 
+    #[external(v0)]
+    fn bad3(ref self: ContractState, class_hash: ClassHash) -> u128 {
+        let _a = 2_u128; // Need this otherwise the compiler inline this function in the wrapper
+        internal_lib_call_1(class_hash)
+    }
+
+    fn internal_lib_call_1(class_hash: ClassHash) -> u128 {
+        internal_lib_call(class_hash)
+    }
+
+
     #[external(v0)]
     fn good(ref self: ContractState) -> u128 {
         IAnotherContractLibraryDispatcher { class_hash: starknet::class_hash_const::<0>() }.foo(2_u128)
diff --git a/tests/detectors/dead_code.cairo b/tests/detectors/dead_code.cairo
index 1dc9ff2..3cc70f6 100644
--- a/tests/detectors/dead_code.cairo
+++ b/tests/detectors/dead_code.cairo
@@ -13,6 +13,8 @@ mod DeadCode {
         amount + 1
     }
 
+    // The compiler completely remove dead code at the sierra representation
+    // so we can not correclty detect dead code as of now
     fn add_2(amount: felt252) -> felt252 {
         amount + 2
     }
diff --git a/tests/detectors/felt252_overflow.cairo b/tests/detectors/felt252_overflow.cairo
index c4010be..193634c 100644
--- a/tests/detectors/felt252_overflow.cairo
+++ b/tests/detectors/felt252_overflow.cairo
@@ -11,14 +11,14 @@ mod Felt252Overflow {
     fn bad_mul_controlled(ref self:ContractState,param1:felt252, param2:felt252, param3:felt252) -> felt252 {
         let max: felt252 = param1 * param2;
         let my: felt252 = param1 * param1;
-        self.b.write(max * param3);
+        self.b.write(max * param3 * my);
         return self.a.read();
     }
 
     #[external(v0)]
     fn bad_add_controlled(ref self:ContractState, user_param:felt252, user_param2: felt252) {
         let a = self.a.read();
-        let controlled = bad_add(user_param, user_param2);
+        let _controlled = bad_add(user_param, user_param2);
         self.b.write(a + user_param+ user_param2);
     }
 
diff --git a/tests/detectors/reentrancy.cairo b/tests/detectors/reentrancy.cairo
index f6b8da1..c16d44f 100644
--- a/tests/detectors/reentrancy.cairo
+++ b/tests/detectors/reentrancy.cairo
@@ -44,7 +44,7 @@ mod TestContract {
 
     #[external(v0)]
     fn bad3(ref self: ContractState, address: ContractAddress) {
-        let a = self.a.read();
+        let _a = self.a.read();
         internal_ext_call(address);
         self.a.write(4);
     }
@@ -70,7 +70,7 @@ mod TestContract {
     }
 
     fn internal_ext_call2(ref self: ContractState, address: ContractAddress) {
-        let a = self.a.read();
+        let _a = self.a.read();
         IAnotherContractDispatcher { contract_address: address }.foo(4);
     }
 
diff --git a/tests/detectors/unchecked_l1_handler_from.cairo b/tests/detectors/unchecked_l1_handler_from.cairo
index c5b73ba..a2679c6 100644
--- a/tests/detectors/unchecked_l1_handler_from.cairo
+++ b/tests/detectors/unchecked_l1_handler_from.cairo
@@ -4,8 +4,8 @@ mod UncheckedL1HandlerFrom {
     struct Storage {}
 
     #[l1_handler]
-    fn bad(self: @ContractState, from_address: felt252) {
-        from_address + 1;
+    fn bad(self: @ContractState, from_address: felt252) -> felt252 {
+        from_address + 1
     }
 
     #[l1_handler]
@@ -24,9 +24,9 @@ mod UncheckedL1HandlerFrom {
     }
 
     #[l1_handler]
-    fn good3(self: @ContractState, from_address: felt252) {
+    fn good3(self: @ContractState, from_address: felt252) -> felt252 {
         let x = check_recursive(from_address, 0);
-        x + 2;
+        x + 2
     }
 
     // Test recursive or looped private function calls
diff --git a/tests/detectors/unused_arguments.cairo b/tests/detectors/unused_arguments.cairo
index 5fa45af..750b1f3 100644
--- a/tests/detectors/unused_arguments.cairo
+++ b/tests/detectors/unused_arguments.cairo
@@ -14,6 +14,7 @@ mod UnusedArguments {
 
     #[external(v0)]
     fn unused_2(self: @ContractState, array: Array::<felt252>, l: felt252) -> felt252{
+        let _a = 1; // Need this otherwise the function is optimized away and put directly in the wrapper
         1
     }
 
diff --git a/tests/detectors/unused_return.cairo b/tests/detectors/unused_return.cairo
index aa22c9c..6d4d6ae 100644
--- a/tests/detectors/unused_return.cairo
+++ b/tests/detectors/unused_return.cairo
@@ -14,8 +14,8 @@ mod UnusedReturn {
 
     #[external(v0)]
     fn unused_return_2(ref self: ContractState, amount: felt252) -> felt252 {
-        let (a,b,d) = f_2(amount);
-        let c = a  ;
+        let (a,_b,_d) = f_2(amount);
+        let _c = a;
         a
     }
 
@@ -26,17 +26,17 @@ mod UnusedReturn {
 
     #[external(v0)]
     fn unused_return_4(ref self: ContractState, amount: felt252) {
-        f_4(amount);
+        let _a = f_4(amount);
     }
 
     #[external(v0)]
     fn unused_return_5(ref self: ContractState) {
-        let a = f_5(ref self);        
+        let _a = f_5(ref self);        
     }
 
     #[external(v0)]
     fn no_report(ref self: ContractState) {
-        let a = self.value.read();
+        let _a = self.value.read();
     }
 
     #[external(v0)]
diff --git a/tests/snapshots/integration_tests__detectors@array_use_after_pop_front.cairo.snap b/tests/snapshots/integration_tests__detectors@array_use_after_pop_front.cairo.snap
index c089120..156ca89 100644
--- a/tests/snapshots/integration_tests__detectors@array_use_after_pop_front.cairo.snap
+++ b/tests/snapshots/integration_tests__detectors@array_use_after_pop_front.cairo.snap
@@ -8,7 +8,7 @@ input_file: tests/detectors/array_use_after_pop_front.cairo
         impact: Low,
         name: "array-use-after-pop-front",
         confidence: Medium,
-        message: "The array [2] is used after removing elements from it in the function array_use_after_pop_front::array_use_after_pop_front::ArrayUseAfterPopFront::bad_loop[expr10]",
+        message: "The array [2] is used after removing elements from it in the function array_use_after_pop_front::array_use_after_pop_front::ArrayUseAfterPopFront::bad_loop[expr11]",
     },
     Result {
         impact: Low,
@@ -44,6 +44,6 @@ input_file: tests/detectors/array_use_after_pop_front.cairo
         impact: Low,
         name: "array-use-after-pop-front",
         confidence: Medium,
-        message: "The arrays [6, 26] are used after removing elements from them in the function array_use_after_pop_front::array_use_after_pop_front::ArrayUseAfterPopFront::bad_multiple_arrays",
+        message: "The arrays [6, 21] are used after removing elements from them in the function array_use_after_pop_front::array_use_after_pop_front::ArrayUseAfterPopFront::bad_multiple_arrays",
     },
 ]
diff --git a/tests/snapshots/integration_tests__detectors@controlled_library_call.cairo.snap b/tests/snapshots/integration_tests__detectors@controlled_library_call.cairo.snap
index 1221adc..d6ce06d 100644
--- a/tests/snapshots/integration_tests__detectors@controlled_library_call.cairo.snap
+++ b/tests/snapshots/integration_tests__detectors@controlled_library_call.cairo.snap
@@ -8,12 +8,12 @@ input_file: tests/detectors/controlled_library_call.cairo
         impact: High,
         name: "controlled-library-call",
         confidence: Medium,
-        message: "Library call to user controlled class hash in controlled_library_call::controlled_library_call::TestContract::bad1\n function_call<user@controlled_library_call::controlled_library_call::IAnotherContractLibraryDispatcherImpl::foo>([11], [12], [13], [14], [15]) -> ([7], [8], [9], [10])",
+        message: "Library call to user controlled class hash in controlled_library_call::controlled_library_call::TestContract::bad1\n function_call<user@controlled_library_call::controlled_library_call::IAnotherContractLibraryDispatcherImpl::foo>([0], [1], [2], [5], [6]) -> ([7], [8], [9], [10])",
     },
     Result {
         impact: High,
         name: "controlled-library-call",
         confidence: Medium,
-        message: "Library call to user controlled class hash in controlled_library_call::controlled_library_call::TestContract::internal_lib_call\n function_call<user@controlled_library_call::controlled_library_call::IAnotherContractLibraryDispatcherImpl::foo>([10], [11], [12], [13], [14]) -> ([6], [7], [8], [9])",
+        message: "Library call to user controlled class hash in controlled_library_call::controlled_library_call::TestContract::internal_lib_call\n function_call<user@controlled_library_call::controlled_library_call::IAnotherContractLibraryDispatcherImpl::foo>([0], [1], [2], [4], [5]) -> ([6], [7], [8], [9])",
     },
 ]
diff --git a/tests/snapshots/integration_tests__detectors@dead_code.cairo.snap b/tests/snapshots/integration_tests__detectors@dead_code.cairo.snap
index 9372330..2a12edd 100644
--- a/tests/snapshots/integration_tests__detectors@dead_code.cairo.snap
+++ b/tests/snapshots/integration_tests__detectors@dead_code.cairo.snap
@@ -10,16 +10,4 @@ input_file: tests/detectors/dead_code.cairo
         confidence: Medium,
         message: "The function dead_code::dead_code::DeadCode::add_1 uses the felt252 operation felt252_add([0], [1]) -> ([2]), which is not overflow/underflow safe",
     },
-    Result {
-        impact: Medium,
-        name: "felt252-unsafe-arithmetic",
-        confidence: Medium,
-        message: "The function dead_code::dead_code::DeadCode::add_2 uses the felt252 operation felt252_add([0], [1]) -> ([2]), which is not overflow/underflow safe",
-    },
-    Result {
-        impact: Low,
-        name: "dead-code",
-        confidence: Medium,
-        message: "Function add_2 defined in dead_code::dead_code::DeadCode is never used",
-    },
 ]
diff --git a/tests/snapshots/integration_tests__detectors@felt252_overflow.cairo.snap b/tests/snapshots/integration_tests__detectors@felt252_overflow.cairo.snap
index a717ff6..7ae3275 100644
--- a/tests/snapshots/integration_tests__detectors@felt252_overflow.cairo.snap
+++ b/tests/snapshots/integration_tests__detectors@felt252_overflow.cairo.snap
@@ -14,13 +14,13 @@ input_file: tests/detectors/felt252_overflow.cairo
         impact: Medium,
         name: "felt252-unsafe-arithmetic",
         confidence: Medium,
-        message: "The function felt252_overflow::felt252_overflow::Felt252Overflow::bad_add_controlled uses the felt252 operation felt252_add([22], [3]) -> ([23]) with the user-controlled parameters: [3], which is not overflow/underflow safe",
+        message: "The function felt252_overflow::felt252_overflow::Felt252Overflow::bad_add_controlled uses the felt252 operation felt252_add([19], [3]) -> ([20]) with the user-controlled parameters: [3], which is not overflow/underflow safe",
     },
     Result {
         impact: Medium,
         name: "felt252-unsafe-arithmetic",
         confidence: Medium,
-        message: "The function felt252_overflow::felt252_overflow::Felt252Overflow::bad_add_controlled uses the felt252 operation felt252_add([23], [4]) -> ([24]) with the user-controlled parameters: [23],[4], which is not overflow/underflow safe",
+        message: "The function felt252_overflow::felt252_overflow::Felt252Overflow::bad_add_controlled uses the felt252 operation felt252_add([20], [4]) -> ([21]) with the user-controlled parameters: [20],[4], which is not overflow/underflow safe",
     },
     Result {
         impact: Medium,
@@ -32,31 +32,37 @@ input_file: tests/detectors/felt252_overflow.cairo
         impact: Medium,
         name: "felt252-unsafe-arithmetic",
         confidence: Medium,
-        message: "The function felt252_overflow::felt252_overflow::Felt252Overflow::bad_mul_controlled uses the felt252 operation felt252_mul([6], [5]) -> ([10]) with the user-controlled parameters: [6],[5], which is not overflow/underflow safe",
+        message: "The function felt252_overflow::felt252_overflow::Felt252Overflow::bad_mul_controlled uses the felt252 operation felt252_mul([10], [3]) -> ([11]) with the user-controlled parameters: [10],[3], which is not overflow/underflow safe",
     },
     Result {
         impact: Medium,
         name: "felt252-unsafe-arithmetic",
         confidence: Medium,
-        message: "The function felt252_overflow::felt252_overflow::Felt252Overflow::bad_mul_controlled uses the felt252 operation felt252_mul([7], [4]) -> ([6]) with the user-controlled parameters: [7],[4], which is not overflow/underflow safe",
+        message: "The function felt252_overflow::felt252_overflow::Felt252Overflow::bad_mul_controlled uses the felt252 operation felt252_mul([12], [11]) -> ([13]) with the user-controlled parameters: [12],[11], which is not overflow/underflow safe",
     },
     Result {
         impact: Medium,
         name: "felt252-unsafe-arithmetic",
         confidence: Medium,
-        message: "The function felt252_overflow::felt252_overflow::Felt252Overflow::bad_mul_controlled uses the felt252 operation felt252_mul([9], [3]) -> ([8]) with the user-controlled parameters: [9],[3], which is not overflow/underflow safe",
+        message: "The function felt252_overflow::felt252_overflow::Felt252Overflow::bad_mul_controlled uses the felt252 operation felt252_mul([8], [4]) -> ([9]) with the user-controlled parameters: [8],[4], which is not overflow/underflow safe",
     },
     Result {
         impact: Medium,
         name: "felt252-unsafe-arithmetic",
         confidence: Medium,
-        message: "The function felt252_overflow::felt252_overflow::Felt252Overflow::bad_sub_controlled uses the felt252 operation felt252_sub([16], [3]) -> ([17]) with the user-controlled parameters: [3], which is not overflow/underflow safe",
+        message: "The function felt252_overflow::felt252_overflow::Felt252Overflow::bad_mul_controlled uses the felt252 operation felt252_mul([9], [5]) -> ([12]) with the user-controlled parameters: [9],[5], which is not overflow/underflow safe",
     },
     Result {
         impact: Medium,
         name: "felt252-unsafe-arithmetic",
         confidence: Medium,
-        message: "The function felt252_overflow::felt252_overflow::Felt252Overflow::bad_sub_uncontrolled uses the felt252 operation felt252_sub([3], [4]) -> ([5]), which is not overflow/underflow safe",
+        message: "The function felt252_overflow::felt252_overflow::Felt252Overflow::bad_sub_controlled uses the felt252 operation felt252_sub([13], [3]) -> ([14]) with the user-controlled parameters: [3], which is not overflow/underflow safe",
+    },
+    Result {
+        impact: Medium,
+        name: "felt252-unsafe-arithmetic",
+        confidence: Medium,
+        message: "The function felt252_overflow::felt252_overflow::Felt252Overflow::bad_sub_uncontrolled uses the felt252 operation felt252_sub([5], [6]) -> ([7]), which is not overflow/underflow safe",
     },
     Result {
         impact: Medium,
@@ -68,6 +74,6 @@ input_file: tests/detectors/felt252_overflow.cairo
         impact: Medium,
         name: "unused-return",
         confidence: Medium,
-        message: "Return value unused for the function call function_call<user@felt252_overflow::felt252_overflow::Felt252Overflow::bad_add>([18], [19]) -> ([17]) in felt252_overflow::felt252_overflow::Felt252Overflow::bad_add_controlled",
+        message: "Return value unused for the function call function_call<user@felt252_overflow::felt252_overflow::Felt252Overflow::bad_add>([14], [15]) -> ([16]) in felt252_overflow::felt252_overflow::Felt252Overflow::bad_add_controlled",
     },
 ]
diff --git a/tests/snapshots/integration_tests__detectors@read_only_reentrancy.cairo.snap b/tests/snapshots/integration_tests__detectors@read_only_reentrancy.cairo.snap
index fbcc462..bca75fe 100644
--- a/tests/snapshots/integration_tests__detectors@read_only_reentrancy.cairo.snap
+++ b/tests/snapshots/integration_tests__detectors@read_only_reentrancy.cairo.snap
@@ -8,12 +8,12 @@ input_file: tests/detectors/read_only_reentrancy.cairo
         impact: Medium,
         name: "read-only-reentrancy",
         confidence: Medium,
-        message: "Read only reentrancy in read_only_reentrancy::read_only_reentrancy::TestContract::get_a\n\tExternal call function_call<user@read_only_reentrancy::read_only_reentrancy::IAnotherContractDispatcherImpl::foo>([9], [10], [11], [12]) -> ([6], [7], [8]) done in read_only_reentrancy::read_only_reentrancy::TestContract::bad\n\tVariable written after function_call<user@read_only_reentrancy::read_only_reentrancy::TestContract::a::InternalContractMemberStateImpl::write>([21], [22], [23], [24]) -> ([18], [19], [20]) in read_only_reentrancy::read_only_reentrancy::TestContract::bad",
+        message: "Read only reentrancy in read_only_reentrancy::read_only_reentrancy::TestContract::get_a\n\tExternal call function_call<user@read_only_reentrancy::read_only_reentrancy::IAnotherContractDispatcherImpl::foo>([0], [1], [4], [5]) -> ([6], [7], [8]) done in read_only_reentrancy::read_only_reentrancy::TestContract::bad\n\tVariable written after function_call<user@read_only_reentrancy::read_only_reentrancy::TestContract::__member_module_a::InternalContractMemberStateImpl::write>([6], [7], [11], [13]) -> ([14], [15], [16]) in read_only_reentrancy::read_only_reentrancy::TestContract::bad",
     },
     Result {
         impact: Low,
         name: "reentrancy-benign",
         confidence: Medium,
-        message: "Reentrancy in read_only_reentrancy::read_only_reentrancy::TestContract::bad\n\tExternal call function_call<user@read_only_reentrancy::read_only_reentrancy::IAnotherContractDispatcherImpl::foo>([9], [10], [11], [12]) -> ([6], [7], [8]) done in read_only_reentrancy::read_only_reentrancy::TestContract::bad\n\tVariable written after function_call<user@read_only_reentrancy::read_only_reentrancy::TestContract::a::InternalContractMemberStateImpl::write>([21], [22], [23], [24]) -> ([18], [19], [20]) in read_only_reentrancy::read_only_reentrancy::TestContract::bad.",
+        message: "Reentrancy in read_only_reentrancy::read_only_reentrancy::TestContract::bad\n\tExternal call function_call<user@read_only_reentrancy::read_only_reentrancy::IAnotherContractDispatcherImpl::foo>([0], [1], [4], [5]) -> ([6], [7], [8]) done in read_only_reentrancy::read_only_reentrancy::TestContract::bad\n\tVariable written after function_call<user@read_only_reentrancy::read_only_reentrancy::TestContract::__member_module_a::InternalContractMemberStateImpl::write>([6], [7], [11], [13]) -> ([14], [15], [16]) in read_only_reentrancy::read_only_reentrancy::TestContract::bad.",
     },
 ]
diff --git a/tests/snapshots/integration_tests__detectors@reentrancy.cairo.snap b/tests/snapshots/integration_tests__detectors@reentrancy.cairo.snap
index 4f7b8b9..b55b622 100644
--- a/tests/snapshots/integration_tests__detectors@reentrancy.cairo.snap
+++ b/tests/snapshots/integration_tests__detectors@reentrancy.cairo.snap
@@ -8,48 +8,48 @@ input_file: tests/detectors/reentrancy.cairo
         impact: Medium,
         name: "reentrancy",
         confidence: Medium,
-        message: "Reentrancy in reentrancy::reentrancy::TestContract::bad1\n\tExternal call function_call<user@reentrancy::reentrancy::IAnotherContractDispatcherImpl::foo>([21], [22], [23], [24]) -> ([18], [19], [20]) done in reentrancy::reentrancy::TestContract::bad1\n\tVariable written after function_call<user@reentrancy::reentrancy::TestContract::a::InternalContractMemberStateImpl::write>([31], [32], [33], [34]) -> ([28], [29], [30]) in reentrancy::reentrancy::TestContract::bad1.",
+        message: "Reentrancy in reentrancy::reentrancy::TestContract::bad1\n\tExternal call function_call<user@reentrancy::reentrancy::IAnotherContractDispatcherImpl::foo>([8], [9], [14], [13]) -> ([15], [16], [17]) done in reentrancy::reentrancy::TestContract::bad1\n\tVariable written after function_call<user@reentrancy::reentrancy::TestContract::__member_module_a::InternalContractMemberStateImpl::write>([15], [16], [6], [20]) -> ([21], [22], [23]) in reentrancy::reentrancy::TestContract::bad1.",
     },
     Result {
         impact: Medium,
         name: "reentrancy",
         confidence: Medium,
-        message: "Reentrancy in reentrancy::reentrancy::TestContract::bad2\n\tExternal call function_call<user@reentrancy::reentrancy::IAnotherContractDispatcherImpl::foo>([25], [26], [27], [28]) -> ([22], [23], [24]) done in reentrancy::reentrancy::TestContract::bad2\n\tVariable written after function_call<user@reentrancy::reentrancy::TestContract::a::InternalContractMemberStateImpl::write>([73], [74], [75], [76]) -> ([70], [71], [72]) in reentrancy::reentrancy::TestContract::bad2.",
+        message: "Reentrancy in reentrancy::reentrancy::TestContract::bad2\n\tExternal call function_call<user@reentrancy::reentrancy::IAnotherContractDispatcherImpl::foo>([12], [13], [18], [17]) -> ([19], [20], [21]) done in reentrancy::reentrancy::TestContract::bad2\n\tVariable written after function_call<user@reentrancy::reentrancy::TestContract::__member_module_a::InternalContractMemberStateImpl::write>([25], [26], [47], [49]) -> ([50], [51], [52]) in reentrancy::reentrancy::TestContract::bad2.",
     },
     Result {
         impact: Medium,
         name: "reentrancy",
         confidence: Medium,
-        message: "Reentrancy in reentrancy::reentrancy::TestContract::bad2\n\tExternal call function_call<user@reentrancy::reentrancy::IAnotherContractDispatcherImpl::foo>([60], [61], [62], [63]) -> ([57], [58], [59]) done in reentrancy::reentrancy::TestContract::bad2\n\tVariable written after function_call<user@reentrancy::reentrancy::TestContract::b::InternalContractMemberStateImpl::write>([83], [84], [85], [86]) -> ([80], [81], [82]) in reentrancy::reentrancy::TestContract::bad2.",
+        message: "Reentrancy in reentrancy::reentrancy::TestContract::bad2\n\tExternal call function_call<user@reentrancy::reentrancy::IAnotherContractDispatcherImpl::foo>([34], [35], [40], [39]) -> ([41], [42], [43]) done in reentrancy::reentrancy::TestContract::bad2\n\tVariable written after function_call<user@reentrancy::reentrancy::TestContract::__member_module_b::InternalContractMemberStateImpl::write>([50], [51], [48], [55]) -> ([56], [57], [58]) in reentrancy::reentrancy::TestContract::bad2.",
     },
     Result {
         impact: Medium,
         name: "reentrancy",
         confidence: Medium,
-        message: "Reentrancy in reentrancy::reentrancy::TestContract::bad3\n\tExternal call function_call<user@reentrancy::reentrancy::IAnotherContractDispatcherImpl::foo>([8], [9], [10], [11]) -> ([5], [6], [7]) done in reentrancy::reentrancy::TestContract::internal_ext_call\n\tVariable written after function_call<user@reentrancy::reentrancy::TestContract::a::InternalContractMemberStateImpl::write>([28], [29], [30], [31]) -> ([25], [26], [27]) in reentrancy::reentrancy::TestContract::bad3.",
+        message: "Reentrancy in reentrancy::reentrancy::TestContract::bad3\n\tExternal call function_call<user@reentrancy::reentrancy::IAnotherContractDispatcherImpl::foo>([0], [1], [3], [4]) -> ([5], [6], [7]) done in reentrancy::reentrancy::TestContract::internal_ext_call\n\tVariable written after function_call<user@reentrancy::reentrancy::TestContract::__member_module_a::InternalContractMemberStateImpl::write>([13], [14], [6], [18]) -> ([19], [20], [21]) in reentrancy::reentrancy::TestContract::bad3.",
     },
     Result {
         impact: Medium,
         name: "reentrancy",
         confidence: Medium,
-        message: "Reentrancy in reentrancy::reentrancy::TestContract::bad4\n\tExternal call function_call<user@reentrancy::reentrancy::IAnotherContractDispatcherImpl::foo>([21], [22], [23], [24]) -> ([18], [19], [20]) done in reentrancy::reentrancy::TestContract::internal_ext_call2\n\tVariable written after function_call<user@reentrancy::reentrancy::TestContract::a::InternalContractMemberStateImpl::write>([21], [22], [23], [24]) -> ([18], [19], [20]) in reentrancy::reentrancy::TestContract::bad4.",
+        message: "Reentrancy in reentrancy::reentrancy::TestContract::bad4\n\tExternal call function_call<user@reentrancy::reentrancy::IAnotherContractDispatcherImpl::foo>([8], [9], [13], [14]) -> ([15], [16], [17]) done in reentrancy::reentrancy::TestContract::internal_ext_call2\n\tVariable written after function_call<user@reentrancy::reentrancy::TestContract::__member_module_a::InternalContractMemberStateImpl::write>([4], [5], [11], [13]) -> ([14], [15], [16]) in reentrancy::reentrancy::TestContract::bad4.",
     },
     Result {
         impact: Medium,
         name: "reentrancy",
         confidence: Medium,
-        message: "Reentrancy in reentrancy::reentrancy::TestContract::bad5\n\tExternal call function_call<user@reentrancy::reentrancy::IAnotherContractDispatcherImpl::foo>([8], [9], [10], [11]) -> ([5], [6], [7]) done in reentrancy::reentrancy::TestContract::bad5[expr8]\n\tVariable written after function_call<user@reentrancy::reentrancy::TestContract::a::InternalContractMemberStateImpl::write>([30], [31], [32], [33]) -> ([27], [28], [29]) in reentrancy::reentrancy::TestContract::bad5.",
+        message: "Reentrancy in reentrancy::reentrancy::TestContract::bad5\n\tExternal call function_call<user@reentrancy::reentrancy::IAnotherContractDispatcherImpl::foo>([0], [1], [4], [3]) -> ([5], [6], [7]) done in reentrancy::reentrancy::TestContract::bad5[expr9]\n\tVariable written after function_call<user@reentrancy::reentrancy::TestContract::__member_module_a::InternalContractMemberStateImpl::write>([14], [15], [6], [19]) -> ([20], [21], [22]) in reentrancy::reentrancy::TestContract::bad5.",
     },
     Result {
         impact: Low,
         name: "reentrancy-benign",
         confidence: Medium,
-        message: "Reentrancy in reentrancy::reentrancy::TestContract::bad2\n\tExternal call function_call<user@reentrancy::reentrancy::IAnotherContractDispatcherImpl::foo>([25], [26], [27], [28]) -> ([22], [23], [24]) done in reentrancy::reentrancy::TestContract::bad2\n\tVariable written after function_call<user@reentrancy::reentrancy::TestContract::b::InternalContractMemberStateImpl::write>([83], [84], [85], [86]) -> ([80], [81], [82]) in reentrancy::reentrancy::TestContract::bad2.",
+        message: "Reentrancy in reentrancy::reentrancy::TestContract::bad2\n\tExternal call function_call<user@reentrancy::reentrancy::IAnotherContractDispatcherImpl::foo>([12], [13], [18], [17]) -> ([19], [20], [21]) done in reentrancy::reentrancy::TestContract::bad2\n\tVariable written after function_call<user@reentrancy::reentrancy::TestContract::__member_module_b::InternalContractMemberStateImpl::write>([50], [51], [48], [55]) -> ([56], [57], [58]) in reentrancy::reentrancy::TestContract::bad2.",
     },
     Result {
         impact: Low,
         name: "reentrancy-benign",
         confidence: Medium,
-        message: "Reentrancy in reentrancy::reentrancy::TestContract::bad2\n\tExternal call function_call<user@reentrancy::reentrancy::IAnotherContractDispatcherImpl::foo>([60], [61], [62], [63]) -> ([57], [58], [59]) done in reentrancy::reentrancy::TestContract::bad2\n\tVariable written after function_call<user@reentrancy::reentrancy::TestContract::a::InternalContractMemberStateImpl::write>([73], [74], [75], [76]) -> ([70], [71], [72]) in reentrancy::reentrancy::TestContract::bad2.",
+        message: "Reentrancy in reentrancy::reentrancy::TestContract::bad2\n\tExternal call function_call<user@reentrancy::reentrancy::IAnotherContractDispatcherImpl::foo>([34], [35], [40], [39]) -> ([41], [42], [43]) done in reentrancy::reentrancy::TestContract::bad2\n\tVariable written after function_call<user@reentrancy::reentrancy::TestContract::__member_module_a::InternalContractMemberStateImpl::write>([25], [26], [47], [49]) -> ([50], [51], [52]) in reentrancy::reentrancy::TestContract::bad2.",
     },
 ]
diff --git a/tests/snapshots/integration_tests__detectors@reentrancy_benign.cairo.snap b/tests/snapshots/integration_tests__detectors@reentrancy_benign.cairo.snap
index 06af3aa..9afe9bb 100644
--- a/tests/snapshots/integration_tests__detectors@reentrancy_benign.cairo.snap
+++ b/tests/snapshots/integration_tests__detectors@reentrancy_benign.cairo.snap
@@ -8,42 +8,42 @@ input_file: tests/detectors/reentrancy_benign.cairo
         impact: Low,
         name: "reentrancy-benign",
         confidence: Medium,
-        message: "Reentrancy in reentrancy_benign::reentrancy_benign::TestContract::bad1\n\tExternal call function_call<user@reentrancy_benign::reentrancy_benign::IAnotherContractDispatcherImpl::foo>([9], [10], [11], [12]) -> ([6], [7], [8]) done in reentrancy_benign::reentrancy_benign::TestContract::bad1\n\tVariable written after function_call<user@reentrancy_benign::reentrancy_benign::TestContract::a::InternalContractMemberStateImpl::write>([21], [22], [23], [24]) -> ([18], [19], [20]) in reentrancy_benign::reentrancy_benign::TestContract::bad1.",
+        message: "Reentrancy in reentrancy_benign::reentrancy_benign::TestContract::bad1\n\tExternal call function_call<user@reentrancy_benign::reentrancy_benign::IAnotherContractDispatcherImpl::foo>([0], [1], [4], [5]) -> ([6], [7], [8]) done in reentrancy_benign::reentrancy_benign::TestContract::bad1\n\tVariable written after function_call<user@reentrancy_benign::reentrancy_benign::TestContract::__member_module_a::InternalContractMemberStateImpl::write>([6], [7], [11], [13]) -> ([14], [15], [16]) in reentrancy_benign::reentrancy_benign::TestContract::bad1.",
     },
     Result {
         impact: Low,
         name: "reentrancy-benign",
         confidence: Medium,
-        message: "Reentrancy in reentrancy_benign::reentrancy_benign::TestContract::bad2\n\tExternal call function_call<user@reentrancy_benign::reentrancy_benign::IAnotherContractDispatcherImpl::foo>([13], [14], [15], [16]) -> ([10], [11], [12]) done in reentrancy_benign::reentrancy_benign::TestContract::bad2\n\tVariable written after function_call<user@reentrancy_benign::reentrancy_benign::TestContract::a::InternalContractMemberStateImpl::write>([42], [43], [44], [45]) -> ([39], [40], [41]) in reentrancy_benign::reentrancy_benign::TestContract::bad2.",
+        message: "Reentrancy in reentrancy_benign::reentrancy_benign::TestContract::bad2\n\tExternal call function_call<user@reentrancy_benign::reentrancy_benign::IAnotherContractDispatcherImpl::foo>([0], [1], [18], [19]) -> ([20], [21], [22]) done in reentrancy_benign::reentrancy_benign::TestContract::bad2\n\tVariable written after function_call<user@reentrancy_benign::reentrancy_benign::TestContract::__member_module_a::InternalContractMemberStateImpl::write>([15], [16], [25], [27]) -> ([28], [29], [30]) in reentrancy_benign::reentrancy_benign::TestContract::bad2.",
     },
     Result {
         impact: Low,
         name: "reentrancy-benign",
         confidence: Medium,
-        message: "Reentrancy in reentrancy_benign::reentrancy_benign::TestContract::bad2\n\tExternal call function_call<user@reentrancy_benign::reentrancy_benign::IAnotherContractDispatcherImpl::foo>([13], [14], [15], [16]) -> ([10], [11], [12]) done in reentrancy_benign::reentrancy_benign::TestContract::bad2\n\tVariable written after function_call<user@reentrancy_benign::reentrancy_benign::TestContract::b::InternalContractMemberStateImpl::write>([52], [53], [54], [55]) -> ([49], [50], [51]) in reentrancy_benign::reentrancy_benign::TestContract::bad2.",
+        message: "Reentrancy in reentrancy_benign::reentrancy_benign::TestContract::bad2\n\tExternal call function_call<user@reentrancy_benign::reentrancy_benign::IAnotherContractDispatcherImpl::foo>([0], [1], [18], [19]) -> ([20], [21], [22]) done in reentrancy_benign::reentrancy_benign::TestContract::bad2\n\tVariable written after function_call<user@reentrancy_benign::reentrancy_benign::TestContract::__member_module_b::InternalContractMemberStateImpl::write>([28], [29], [26], [33]) -> ([34], [35], [36]) in reentrancy_benign::reentrancy_benign::TestContract::bad2.",
     },
     Result {
         impact: Low,
         name: "reentrancy-benign",
         confidence: Medium,
-        message: "Reentrancy in reentrancy_benign::reentrancy_benign::TestContract::bad2\n\tExternal call function_call<user@reentrancy_benign::reentrancy_benign::IAnotherContractDispatcherImpl::foo>([30], [31], [32], [33]) -> ([27], [28], [29]) done in reentrancy_benign::reentrancy_benign::TestContract::bad2\n\tVariable written after function_call<user@reentrancy_benign::reentrancy_benign::TestContract::a::InternalContractMemberStateImpl::write>([42], [43], [44], [45]) -> ([39], [40], [41]) in reentrancy_benign::reentrancy_benign::TestContract::bad2.",
+        message: "Reentrancy in reentrancy_benign::reentrancy_benign::TestContract::bad2\n\tExternal call function_call<user@reentrancy_benign::reentrancy_benign::IAnotherContractDispatcherImpl::foo>([0], [1], [8], [9]) -> ([10], [11], [12]) done in reentrancy_benign::reentrancy_benign::TestContract::bad2\n\tVariable written after function_call<user@reentrancy_benign::reentrancy_benign::TestContract::__member_module_a::InternalContractMemberStateImpl::write>([15], [16], [25], [27]) -> ([28], [29], [30]) in reentrancy_benign::reentrancy_benign::TestContract::bad2.",
     },
     Result {
         impact: Low,
         name: "reentrancy-benign",
         confidence: Medium,
-        message: "Reentrancy in reentrancy_benign::reentrancy_benign::TestContract::bad2\n\tExternal call function_call<user@reentrancy_benign::reentrancy_benign::IAnotherContractDispatcherImpl::foo>([30], [31], [32], [33]) -> ([27], [28], [29]) done in reentrancy_benign::reentrancy_benign::TestContract::bad2\n\tVariable written after function_call<user@reentrancy_benign::reentrancy_benign::TestContract::b::InternalContractMemberStateImpl::write>([52], [53], [54], [55]) -> ([49], [50], [51]) in reentrancy_benign::reentrancy_benign::TestContract::bad2.",
+        message: "Reentrancy in reentrancy_benign::reentrancy_benign::TestContract::bad2\n\tExternal call function_call<user@reentrancy_benign::reentrancy_benign::IAnotherContractDispatcherImpl::foo>([0], [1], [8], [9]) -> ([10], [11], [12]) done in reentrancy_benign::reentrancy_benign::TestContract::bad2\n\tVariable written after function_call<user@reentrancy_benign::reentrancy_benign::TestContract::__member_module_b::InternalContractMemberStateImpl::write>([28], [29], [26], [33]) -> ([34], [35], [36]) in reentrancy_benign::reentrancy_benign::TestContract::bad2.",
     },
     Result {
         impact: Low,
         name: "reentrancy-benign",
         confidence: Medium,
-        message: "Reentrancy in reentrancy_benign::reentrancy_benign::TestContract::bad3\n\tExternal call function_call<user@reentrancy_benign::reentrancy_benign::IAnotherContractDispatcherImpl::foo>([8], [9], [10], [11]) -> ([5], [6], [7]) done in reentrancy_benign::reentrancy_benign::TestContract::internal_ext_call\n\tVariable written after function_call<user@reentrancy_benign::reentrancy_benign::TestContract::a::InternalContractMemberStateImpl::write>([18], [19], [20], [21]) -> ([15], [16], [17]) in reentrancy_benign::reentrancy_benign::TestContract::bad3.",
+        message: "Reentrancy in reentrancy_benign::reentrancy_benign::TestContract::bad3\n\tExternal call function_call<user@reentrancy_benign::reentrancy_benign::IAnotherContractDispatcherImpl::foo>([0], [1], [3], [4]) -> ([5], [6], [7]) done in reentrancy_benign::reentrancy_benign::TestContract::internal_ext_call\n\tVariable written after function_call<user@reentrancy_benign::reentrancy_benign::TestContract::__member_module_a::InternalContractMemberStateImpl::write>([4], [5], [9], [11]) -> ([12], [13], [14]) in reentrancy_benign::reentrancy_benign::TestContract::bad3.",
     },
     Result {
         impact: Low,
         name: "reentrancy-benign",
         confidence: Medium,
-        message: "Reentrancy in reentrancy_benign::reentrancy_benign::TestContract::bad4\n\tExternal call function_call<user@reentrancy_benign::reentrancy_benign::IAnotherContractDispatcherImpl::foo>([8], [9], [10], [11]) -> ([5], [6], [7]) done in reentrancy_benign::reentrancy_benign::TestContract::internal_ext_call2\n\tVariable written after function_call<user@reentrancy_benign::reentrancy_benign::TestContract::a::InternalContractMemberStateImpl::write>([18], [19], [20], [21]) -> ([15], [16], [17]) in reentrancy_benign::reentrancy_benign::TestContract::bad4.",
+        message: "Reentrancy in reentrancy_benign::reentrancy_benign::TestContract::bad4\n\tExternal call function_call<user@reentrancy_benign::reentrancy_benign::IAnotherContractDispatcherImpl::foo>([0], [1], [3], [4]) -> ([5], [6], [7]) done in reentrancy_benign::reentrancy_benign::TestContract::internal_ext_call2\n\tVariable written after function_call<user@reentrancy_benign::reentrancy_benign::TestContract::__member_module_a::InternalContractMemberStateImpl::write>([4], [5], [9], [11]) -> ([12], [13], [14]) in reentrancy_benign::reentrancy_benign::TestContract::bad4.",
     },
 ]
diff --git a/tests/snapshots/integration_tests__detectors@reentrancy_events.cairo.snap b/tests/snapshots/integration_tests__detectors@reentrancy_events.cairo.snap
index 267fab0..d294719 100644
--- a/tests/snapshots/integration_tests__detectors@reentrancy_events.cairo.snap
+++ b/tests/snapshots/integration_tests__detectors@reentrancy_events.cairo.snap
@@ -8,6 +8,6 @@ input_file: tests/detectors/reentrancy_events.cairo
         impact: Low,
         name: "reentrancy-events",
         confidence: Medium,
-        message: "Reentrancy in reentrancy_events::reentrancy_events::TestContract::bad1\n\tExternal call function_call<user@reentrancy_events::reentrancy_events::IAnotherContractDispatcherImpl::foo>([9], [10], [11], [12]) -> ([6], [7], [8]) done in reentrancy_events::reentrancy_events::TestContract::bad1\n\tEvent emitted after function_call<user@reentrancy_events::reentrancy_events::TestContract::ContractStateEventEmitter::emit::<reentrancy_events::reentrancy_events::TestContract::MyEvent, reentrancy_events::reentrancy_events::TestContract::EventMyEventIntoEvent>>([19], [20], [21], [22]) -> ([16], [17], [18]) in reentrancy_events::reentrancy_events::TestContract::bad1.",
+        message: "Reentrancy in reentrancy_events::reentrancy_events::TestContract::bad1\n\tExternal call function_call<user@reentrancy_events::reentrancy_events::IAnotherContractDispatcherImpl::foo>([0], [1], [4], [5]) -> ([6], [7], [8]) done in reentrancy_events::reentrancy_events::TestContract::bad1\n\tEvent emitted after function_call<user@reentrancy_events::reentrancy_events::TestContract::ContractStateEventEmitter::emit::<reentrancy_events::reentrancy_events::TestContract::MyEvent, reentrancy_events::reentrancy_events::TestContract::EventMyEventIntoEvent>>([6], [7], [2], [11]) -> ([12], [13], [14]) in reentrancy_events::reentrancy_events::TestContract::bad1.",
     },
 ]
diff --git a/tests/snapshots/integration_tests__detectors@unchecked_l1_handler_from.cairo.snap b/tests/snapshots/integration_tests__detectors@unchecked_l1_handler_from.cairo.snap
index 83e6d8d..4b0951f 100644
--- a/tests/snapshots/integration_tests__detectors@unchecked_l1_handler_from.cairo.snap
+++ b/tests/snapshots/integration_tests__detectors@unchecked_l1_handler_from.cairo.snap
@@ -20,18 +20,12 @@ input_file: tests/detectors/unchecked_l1_handler_from.cairo
         impact: Medium,
         name: "felt252-unsafe-arithmetic",
         confidence: Medium,
-        message: "The function unchecked_l1_handler_from::unchecked_l1_handler_from::UncheckedL1HandlerFrom::check_recursive uses the felt252 operation felt252_add([3], [50]) -> ([51]), which is not overflow/underflow safe",
+        message: "The function unchecked_l1_handler_from::unchecked_l1_handler_from::UncheckedL1HandlerFrom::check_recursive uses the felt252 operation felt252_add([3], [36]) -> ([37]), which is not overflow/underflow safe",
     },
     Result {
         impact: Medium,
         name: "felt252-unsafe-arithmetic",
         confidence: Medium,
-        message: "The function unchecked_l1_handler_from::unchecked_l1_handler_from::UncheckedL1HandlerFrom::check_recursive uses the felt252 operation felt252_sub([11], [9]) -> ([10]), which is not overflow/underflow safe",
-    },
-    Result {
-        impact: Medium,
-        name: "felt252-unsafe-arithmetic",
-        confidence: Medium,
-        message: "The function unchecked_l1_handler_from::unchecked_l1_handler_from::UncheckedL1HandlerFrom::good3 uses the felt252 operation felt252_add([14], [15]) -> ([16]) with the user-controlled parameters: [14], which is not overflow/underflow safe",
+        message: "The function unchecked_l1_handler_from::unchecked_l1_handler_from::UncheckedL1HandlerFrom::good3 uses the felt252 operation felt252_add([10], [11]) -> ([12]) with the user-controlled parameters: [10], which is not overflow/underflow safe",
     },
 ]
diff --git a/tests/snapshots/integration_tests__detectors@unused_return.cairo.snap b/tests/snapshots/integration_tests__detectors@unused_return.cairo.snap
index 86f83dd..a3218e7 100644
--- a/tests/snapshots/integration_tests__detectors@unused_return.cairo.snap
+++ b/tests/snapshots/integration_tests__detectors@unused_return.cairo.snap
@@ -8,36 +8,36 @@ input_file: tests/detectors/unused_return.cairo
         impact: Medium,
         name: "felt252-unsafe-arithmetic",
         confidence: Medium,
-        message: "The function unused_return::unused_return::UnusedReturn::f_5 uses the felt252 operation felt252_mul([14], [15]) -> ([16]), which is not overflow/underflow safe",
+        message: "The function unused_return::unused_return::UnusedReturn::f_5 uses the felt252 operation felt252_mul([11], [12]) -> ([13]), which is not overflow/underflow safe",
     },
     Result {
         impact: Medium,
         name: "unused-return",
         confidence: Medium,
-        message: "Return value unused for the function call function_call<user@unused_return::unused_return::UnusedReturn::f_1>([7], [8], [9], [10]) -> ([4], [5], [6]) in unused_return::unused_return::UnusedReturn::unused_return_1",
+        message: "Return value unused for the function call function_call<user@unused_return::unused_return::UnusedReturn::f_1>([0], [1], [2], [3]) -> ([4], [5], [6]) in unused_return::unused_return::UnusedReturn::unused_return_1",
     },
     Result {
         impact: Medium,
         name: "unused-return",
         confidence: Medium,
-        message: "Return value unused for the function call function_call<user@unused_return::unused_return::UnusedReturn::f_2>([3]) -> ([2]) in unused_return::unused_return::UnusedReturn::unused_return_2",
+        message: "Return value unused for the function call function_call<user@unused_return::unused_return::UnusedReturn::f_2>([1]) -> ([2]) in unused_return::unused_return::UnusedReturn::unused_return_2",
     },
     Result {
         impact: Medium,
         name: "unused-return",
         confidence: Medium,
-        message: "Return value unused for the function call function_call<user@unused_return::unused_return::UnusedReturn::f_3>([3]) -> ([2]) in unused_return::unused_return::UnusedReturn::unused_return_3",
+        message: "Return value unused for the function call function_call<user@unused_return::unused_return::UnusedReturn::f_3>([1]) -> ([2]) in unused_return::unused_return::UnusedReturn::unused_return_3",
     },
     Result {
         impact: Medium,
         name: "unused-return",
         confidence: Medium,
-        message: "Return value unused for the function call function_call<user@unused_return::unused_return::UnusedReturn::f_4>([3]) -> ([2]) in unused_return::unused_return::UnusedReturn::unused_return_4",
+        message: "Return value unused for the function call function_call<user@unused_return::unused_return::UnusedReturn::f_4>([1]) -> ([2]) in unused_return::unused_return::UnusedReturn::unused_return_4",
     },
     Result {
         impact: Medium,
         name: "unused-return",
         confidence: Medium,
-        message: "Return value unused for the function call function_call<user@unused_return::unused_return::UnusedReturn::f_5>([6], [7], [8]) -> ([3], [4], [5]) in unused_return::unused_return::UnusedReturn::unused_return_5",
+        message: "Return value unused for the function call function_call<user@unused_return::unused_return::UnusedReturn::f_5>([0], [1], [2]) -> ([3], [4], [5]) in unused_return::unused_return::UnusedReturn::unused_return_5",
     },
 ]