From 138005560ff0fbf6f66886e95a3e1607f66ee1e2 Mon Sep 17 00:00:00 2001
From: ZamDimon <zamdmytro@gmail.com>
Date: Mon, 16 Sep 2024 14:06:07 +0300
Subject: [PATCH 01/17] :construction: :test_tube: add test scripts that will
 be used for verification

---
 splitter/Cargo.toml                  | 49 +++++++++++-----------
 splitter/src/debug.rs                |  2 +-
 splitter/src/lib.rs                  |  2 +
 splitter/src/split/mod.rs            |  4 ++
 splitter/src/split/script.rs         | 62 ++++++++++++++++++++++++++++
 splitter/src/test_scripts/int_add.rs | 56 +++++++++++++++++++++++++
 splitter/src/test_scripts/int_mul.rs |  4 ++
 splitter/src/test_scripts/mod.rs     |  9 ++++
 8 files changed, 163 insertions(+), 25 deletions(-)
 create mode 100644 splitter/src/split/mod.rs
 create mode 100644 splitter/src/split/script.rs
 create mode 100644 splitter/src/test_scripts/int_add.rs
 create mode 100644 splitter/src/test_scripts/int_mul.rs
 create mode 100644 splitter/src/test_scripts/mod.rs

diff --git a/splitter/Cargo.toml b/splitter/Cargo.toml
index 52e2e15..c532339 100644
--- a/splitter/Cargo.toml
+++ b/splitter/Cargo.toml
@@ -1,36 +1,37 @@
 [package]
-name = "splitter"
+name    = "bitvm2-splitter"
 version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-
 # Bitcoin Libraries
 bitcoin              = { git = "https://github.com/rust-bitcoin/rust-bitcoin", branch = "bitvm", features = ["rand-std"]}
 bitcoin-script       = { git = "https://github.com/BitVM/rust-bitcoin-script" }
 bitcoin-scriptexec   = { git = "https://github.com/BitVM/rust-bitcoin-scriptexec/"}
 bitcoin-script-stack = { git = "https://github.com/FairgateLabs/rust-bitcoin-script-stack"}
+# Some test script to test the splitter
+bitcoin-window-mul   = { git = "https://github.com/distributed-lab/bitcoin-window-mul.git" }
+
+# General-purpose libraries
+strum          = "0.26"
+strum_macros   = "0.26"
+serde          = { version = "1.0.197", features = ["derive"] }
+serde_json     = "1.0.116"
+tokio          = { version = "1.37.0", features = ["full"] }
 
-# Other Libraries
-strum = "0.26"
-strum_macros = "0.26"
-hex = "0.4.3"
-serde = { version = "1.0.197", features = ["derive"] }
+# Crypto libraries
+hex        = "0.4.3"
 num-bigint = "0.4.4"
 num-traits = "0.2.18"
-tokio = { version = "1.37.0", features = ["full"] }
-serde_json = "1.0.116"
-lazy_static = "1.4.0"
-prettytable-rs = "0.10.0"
-paste = "1.0"
-seq-macro = "0.3.5"
 
-[dev-dependencies]
+# Random libraries
 rand_chacha = "0.3.1"
-rand = "0.8.5"
-num-bigint = { version = "0.4.4", features = ["rand"] }
-ark-std = "0.4.0"
-konst = "0.3.9"
+rand        = "0.8.0"
+
+[dev-dependencies]
+num-bigint  = { version = "0.4.4", features = ["rand"] }
+ark-std     = "0.4.0"
+konst       = "0.3.9"
 
 [profile.dev]
 opt-level = 3
@@ -39,25 +40,25 @@ opt-level = 3
 lto = true
 
 [patch.crates-io.base58check]
-git = "https://github.com/rust-bitcoin/rust-bitcoin"
+git    = "https://github.com/rust-bitcoin/rust-bitcoin"
 branch = "bitvm"
 
 [patch.crates-io.bitcoin]
-git = "https://github.com/rust-bitcoin/rust-bitcoin"
+git    = "https://github.com/rust-bitcoin/rust-bitcoin"
 branch = "bitvm"
 
 [patch.crates-io.bitcoin_hashes]
-git = "https://github.com/rust-bitcoin/rust-bitcoin"
+git    = "https://github.com/rust-bitcoin/rust-bitcoin"
 branch = "bitvm"
 
 [patch.crates-io.bitcoin-internals]
-git = "https://github.com/rust-bitcoin/rust-bitcoin"
+git    = "https://github.com/rust-bitcoin/rust-bitcoin"
 branch = "bitvm"
 
 [patch.crates-io.bitcoin-io]
-git = "https://github.com/rust-bitcoin/rust-bitcoin"
+git    = "https://github.com/rust-bitcoin/rust-bitcoin"
 branch = "bitvm"
 
 [patch.crates-io.bitcoin-units]
-git = "https://github.com/rust-bitcoin/rust-bitcoin"
+git    = "https://github.com/rust-bitcoin/rust-bitcoin"
 branch = "bitvm"
\ No newline at end of file
diff --git a/splitter/src/debug.rs b/splitter/src/debug.rs
index eac8890..3584b1e 100644
--- a/splitter/src/debug.rs
+++ b/splitter/src/debug.rs
@@ -202,4 +202,4 @@ mod test {
         let exec_result = execute_script_no_stack_limit(script);
         assert!(exec_result.success);
     }
-}
\ No newline at end of file
+}
diff --git a/splitter/src/lib.rs b/splitter/src/lib.rs
index 6dc88ea..ae7e007 100644
--- a/splitter/src/lib.rs
+++ b/splitter/src/lib.rs
@@ -9,6 +9,8 @@ pub mod treepp {
 }
 
 pub(crate) mod debug;
+pub mod split;
+pub(crate) mod test_scripts;
 
 #[cfg(test)]
 mod tests {
diff --git a/splitter/src/split/mod.rs b/splitter/src/split/mod.rs
new file mode 100644
index 0000000..065720b
--- /dev/null
+++ b/splitter/src/split/mod.rs
@@ -0,0 +1,4 @@
+//! Module that contains the implementation of the splitter
+//! together with all auxiliary functions and data structures.
+
+pub mod script;
diff --git a/splitter/src/split/script.rs b/splitter/src/split/script.rs
new file mode 100644
index 0000000..79a6261
--- /dev/null
+++ b/splitter/src/split/script.rs
@@ -0,0 +1,62 @@
+//! Module containing the structure for scripts that we are going to use
+
+use bitcoin_script_stack::debugger::pushable::Pushable;
+
+use crate::treepp::*;
+
+/// Structure that represents a pair of input and output scripts. Typically, the prover
+/// wants to prove `script(input) == output`
+pub struct IOPair<
+    I, O: Pushable,
+    const INPUT_SIZE: usize, 
+    const OUTPUT_SIZE: usize,
+> {
+    pub input: [I; INPUT_SIZE],
+    pub output: [O; OUTPUT_SIZE],
+}
+
+/// Trait that any script that can be split should implement
+pub trait SplitableScript<I, O: Pushable, const INPUT_SIZE: usize, const OUTPUT_SIZE: usize> {
+    /// Returns the main logic (f) of the script
+    fn script() -> Script;
+
+    /// Generates a random valid input for the script
+    fn generate_valid_io_pair() -> IOPair<I, O, INPUT_SIZE, OUTPUT_SIZE>;
+
+    /// Verifies that the input is valid for the script
+    fn verify(input: [I; INPUT_SIZE], output: [O; OUTPUT_SIZE]) -> bool {
+        let output_length = output.len();
+        println!("Output length: {}", output_length);
+
+        let script = script! {
+            for i in 0..input.len() {
+                { input[i] }
+            }
+
+            { Self::script() }
+            for i in 0..input.len() {
+                { output[i] }
+            }
+
+            // Now, we need to verify that the output is correct.
+            // Since the output is not necessarily a single element, we check
+            // elements one by one
+            for i in (0..output_length).rev() {
+                // { <a_1> <a_2> ... <a_n> <b_1> <b_2> ... <b_n> } <- we need to push element <a_n> to the top of the stack
+                { i+1 } OP_ROLL
+                OP_EQUALVERIFY
+            }
+
+            // If everything was verified correctly, we return true to mark the script as successful
+            OP_TRUE
+        };
+
+        execute_script(script).success
+    }
+
+    /// Verifies that the input is valid for the script with random input and output
+    fn verify_random() -> bool {
+        let IOPair { input, output } = Self::generate_valid_io_pair();
+        Self::verify(input, output)
+    }
+}
diff --git a/splitter/src/test_scripts/int_add.rs b/splitter/src/test_scripts/int_add.rs
new file mode 100644
index 0000000..4046453
--- /dev/null
+++ b/splitter/src/test_scripts/int_add.rs
@@ -0,0 +1,56 @@
+//! This module contains the test script
+//! for performing the addition of two large integers (exceeding standard Bitcoin 31-bit integers)
+
+use crate::{
+    split::script::{IOPair, SplitableScript},
+    treepp::*,
+};
+use bitcoin_window_mul::{
+    bigint::{U254Windowed, U254},
+    traits::{arithmeticable::Arithmeticable, integer::NonNativeInteger},
+};
+
+use core::ops::{Rem, Shl};
+use num_bigint::{BigUint, RandomBits};
+use num_traits::One;
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha20Rng;
+
+/// Script that performs the addition of two 254-bit numbers
+pub struct U254AddScript;
+
+impl SplitableScript for U254AddScript {
+    fn script() -> Script {
+        U254::OP_ADD(1, 0)
+    }
+
+    fn generate_valid_io_pair() -> IOPair {
+        let mut prng = ChaCha20Rng::seed_from_u64(0);
+
+        let a: BigUint = prng.sample(RandomBits::new(254));
+        let b: BigUint = prng.sample(RandomBits::new(254));
+        let c: BigUint = (a.clone() + b.clone()).rem(BigUint::one().shl(254));
+
+        println!("a: {}", a);
+        println!("b: {}", b);
+        println!("c: {}", c);
+
+        IOPair {
+            input: script! {
+                { U254::OP_PUSH_U32LESLICE(&a.to_u32_digits()) }
+                { U254::OP_PUSH_U32LESLICE(&b.to_u32_digits()) }
+            },
+            output: U254::OP_PUSH_U32LESLICE(&c.to_u32_digits()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_verify() {
+        assert!(U254AddScript::verify_random());
+    }
+}
\ No newline at end of file
diff --git a/splitter/src/test_scripts/int_mul.rs b/splitter/src/test_scripts/int_mul.rs
new file mode 100644
index 0000000..209b819
--- /dev/null
+++ b/splitter/src/test_scripts/int_mul.rs
@@ -0,0 +1,4 @@
+//! This module contains the test script
+//! for performing the multiplication of two large integers (exceeding standard Bitcoin 31-bit integers)
+
+use crate::treepp::*;
diff --git a/splitter/src/test_scripts/mod.rs b/splitter/src/test_scripts/mod.rs
new file mode 100644
index 0000000..26548cf
--- /dev/null
+++ b/splitter/src/test_scripts/mod.rs
@@ -0,0 +1,9 @@
+//! This module contains some test scripts to test
+//! the functionality of the splitter.
+//!
+//! Namely, we include:
+//! - A script that performs an addition of two 254-bit numbers.
+//! - A script that performs a multiplication of two 254-bit numbers using w-windowed approach.
+
+pub(crate) mod int_add;
+pub(crate) mod int_mul;

From f1cfd1c15acdb15b9a91901c5407050ae860f8d0 Mon Sep 17 00:00:00 2001
From: ZamDimon <zamdmytro@gmail.com>
Date: Mon, 16 Sep 2024 14:19:58 +0300
Subject: [PATCH 02/17] :adhesive_bandage: resolve conflicts in `Cargo.toml`

---
 splitter/Cargo.toml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/splitter/Cargo.toml b/splitter/Cargo.toml
index 0737c9b..383809d 100644
--- a/splitter/Cargo.toml
+++ b/splitter/Cargo.toml
@@ -21,12 +21,11 @@ tokio          = { version = "1.37.0", features = ["full"] }
 
 # Crypto libraries
 hex        = "0.4.3"
-num-bigint = "0.4.4"
+num-bigint = { version = "0.4.4", features = ["rand"] }
 num-traits = "0.2.18"
 
 # Random libraries
 rand_chacha = "0.3.1"
 rand        = "0.8.5"
-num-bigint  = { version = "0.4.4", features = ["rand"] }
 ark-std     = "0.4.0"
 konst       = "0.3.9"

From 7e5a68c33d42e518f9674a6d60d5232cb4307cd1 Mon Sep 17 00:00:00 2001
From: ZamDimon <zamdmytro@gmail.com>
Date: Mon, 16 Sep 2024 15:07:44 +0300
Subject: [PATCH 03/17] :construction: almost there

---
 splitter/src/split/script.rs         |  8 ++-----
 splitter/src/test_scripts/int_add.rs | 32 +++++++++++++++++-----------
 splitter/src/test_scripts/int_mul.rs |  1 +
 3 files changed, 22 insertions(+), 19 deletions(-)

diff --git a/splitter/src/split/script.rs b/splitter/src/split/script.rs
index 79a6261..79af118 100644
--- a/splitter/src/split/script.rs
+++ b/splitter/src/split/script.rs
@@ -1,16 +1,12 @@
 //! Module containing the structure for scripts that we are going to use
 
-use bitcoin_script_stack::debugger::pushable::Pushable;
+use pushable::Pushable;
 
 use crate::treepp::*;
 
 /// Structure that represents a pair of input and output scripts. Typically, the prover
 /// wants to prove `script(input) == output`
-pub struct IOPair<
-    I, O: Pushable,
-    const INPUT_SIZE: usize, 
-    const OUTPUT_SIZE: usize,
-> {
+pub struct IOPair<I, O: Pushable, const INPUT_SIZE: usize, const OUTPUT_SIZE: usize> {
     pub input: [I; INPUT_SIZE],
     pub output: [O; OUTPUT_SIZE],
 }
diff --git a/splitter/src/test_scripts/int_add.rs b/splitter/src/test_scripts/int_add.rs
index 4046453..3440487 100644
--- a/splitter/src/test_scripts/int_add.rs
+++ b/splitter/src/test_scripts/int_add.rs
@@ -6,8 +6,8 @@ use crate::{
     treepp::*,
 };
 use bitcoin_window_mul::{
-    bigint::{U254Windowed, U254},
-    traits::{arithmeticable::Arithmeticable, integer::NonNativeInteger},
+    bigint::U254,
+    traits::{arithmeticable::Arithmeticable, integer::NonNativeLimbInteger},
 };
 
 use core::ops::{Rem, Shl};
@@ -19,28 +19,34 @@ use rand_chacha::ChaCha20Rng;
 /// Script that performs the addition of two 254-bit numbers
 pub struct U254AddScript;
 
-impl SplitableScript for U254AddScript {
+type IOType = u32;
+const INPUT_SIZE: usize = 2 * U254::N_LIMBS;
+const OUTPUT_SIZE: usize = U254::N_LIMBS;
+
+impl SplitableScript<IOType, IOType, { INPUT_SIZE }, { OUTPUT_SIZE }> for U254AddScript {
     fn script() -> Script {
         U254::OP_ADD(1, 0)
     }
 
-    fn generate_valid_io_pair() -> IOPair {
+    fn generate_valid_io_pair() -> IOPair<IOType, IOType, { INPUT_SIZE }, { OUTPUT_SIZE }> {
         let mut prng = ChaCha20Rng::seed_from_u64(0);
 
         let a: BigUint = prng.sample(RandomBits::new(254));
         let b: BigUint = prng.sample(RandomBits::new(254));
         let c: BigUint = (a.clone() + b.clone()).rem(BigUint::one().shl(254));
 
-        println!("a: {}", a);
-        println!("b: {}", b);
-        println!("c: {}", c);
+        // Input is simply a and b limbs concatenated
+        let mut input = a.to_u32_digits().clone();
+        input.append(&mut b.to_u32_digits());
+
+        // Output is limbs of c
+        let output = c.to_u32_digits();
 
         IOPair {
-            input: script! {
-                { U254::OP_PUSH_U32LESLICE(&a.to_u32_digits()) }
-                { U254::OP_PUSH_U32LESLICE(&b.to_u32_digits()) }
-            },
-            output: U254::OP_PUSH_U32LESLICE(&c.to_u32_digits()),
+            input: input.try_into().expect("Input is not of the correct size"),
+            output: output
+                .try_into()
+                .expect("Output is not of the correct size"),
         }
     }
 }
@@ -53,4 +59,4 @@ mod tests {
     fn test_verify() {
         assert!(U254AddScript::verify_random());
     }
-}
\ No newline at end of file
+}
diff --git a/splitter/src/test_scripts/int_mul.rs b/splitter/src/test_scripts/int_mul.rs
index 209b819..101c7e4 100644
--- a/splitter/src/test_scripts/int_mul.rs
+++ b/splitter/src/test_scripts/int_mul.rs
@@ -1,4 +1,5 @@
 //! This module contains the test script
 //! for performing the multiplication of two large integers (exceeding standard Bitcoin 31-bit integers)
 
+#[allow(unused_imports)]
 use crate::treepp::*;

From 00c0a28cb715285bcc0e099742f0958b31e98ba9 Mon Sep 17 00:00:00 2001
From: ZamDimon <zamdmytro@gmail.com>
Date: Mon, 16 Sep 2024 15:21:31 +0300
Subject: [PATCH 04/17] :green_heart: make it somewhat working

---
 splitter/src/split/script.rs         | 30 +++++++++---------------
 splitter/src/test_scripts/int_add.rs | 34 +++++++++++++---------------
 2 files changed, 27 insertions(+), 37 deletions(-)

diff --git a/splitter/src/split/script.rs b/splitter/src/split/script.rs
index 79af118..c60bb56 100644
--- a/splitter/src/split/script.rs
+++ b/splitter/src/split/script.rs
@@ -1,43 +1,35 @@
 //! Module containing the structure for scripts that we are going to use
 
-use pushable::Pushable;
-
 use crate::treepp::*;
 
 /// Structure that represents a pair of input and output scripts. Typically, the prover
 /// wants to prove `script(input) == output`
-pub struct IOPair<I, O: Pushable, const INPUT_SIZE: usize, const OUTPUT_SIZE: usize> {
-    pub input: [I; INPUT_SIZE],
-    pub output: [O; OUTPUT_SIZE],
+pub struct IOPair<const INPUT_SIZE: usize, const OUTPUT_SIZE: usize> {
+    /// Input script containing the elements which will be fed to the main script
+    pub input: Script,
+    /// Output script containing the elements which will be compared to the output of the main script
+    pub output: Script,
 }
 
 /// Trait that any script that can be split should implement
-pub trait SplitableScript<I, O: Pushable, const INPUT_SIZE: usize, const OUTPUT_SIZE: usize> {
+pub trait SplitableScript<const INPUT_SIZE: usize, const OUTPUT_SIZE: usize> {
     /// Returns the main logic (f) of the script
     fn script() -> Script;
 
     /// Generates a random valid input for the script
-    fn generate_valid_io_pair() -> IOPair<I, O, INPUT_SIZE, OUTPUT_SIZE>;
+    fn generate_valid_io_pair() -> IOPair<INPUT_SIZE, OUTPUT_SIZE>;
 
     /// Verifies that the input is valid for the script
-    fn verify(input: [I; INPUT_SIZE], output: [O; OUTPUT_SIZE]) -> bool {
-        let output_length = output.len();
-        println!("Output length: {}", output_length);
-
+    fn verify(input: Script, output: Script) -> bool {
         let script = script! {
-            for i in 0..input.len() {
-                { input[i] }
-            }
-
+            { input }
             { Self::script() }
-            for i in 0..input.len() {
-                { output[i] }
-            }
+            { output }
 
             // Now, we need to verify that the output is correct.
             // Since the output is not necessarily a single element, we check
             // elements one by one
-            for i in (0..output_length).rev() {
+            for i in (0..OUTPUT_SIZE).rev() {
                 // { <a_1> <a_2> ... <a_n> <b_1> <b_2> ... <b_n> } <- we need to push element <a_n> to the top of the stack
                 { i+1 } OP_ROLL
                 OP_EQUALVERIFY
diff --git a/splitter/src/test_scripts/int_add.rs b/splitter/src/test_scripts/int_add.rs
index 3440487..62903ba 100644
--- a/splitter/src/test_scripts/int_add.rs
+++ b/splitter/src/test_scripts/int_add.rs
@@ -7,7 +7,10 @@ use crate::{
 };
 use bitcoin_window_mul::{
     bigint::U254,
-    traits::{arithmeticable::Arithmeticable, integer::NonNativeLimbInteger},
+    traits::{
+        arithmeticable::Arithmeticable,
+        integer::{NonNativeInteger, NonNativeLimbInteger},
+    },
 };
 
 use core::ops::{Rem, Shl};
@@ -19,34 +22,29 @@ use rand_chacha::ChaCha20Rng;
 /// Script that performs the addition of two 254-bit numbers
 pub struct U254AddScript;
 
-type IOType = u32;
+/// Input size is double the number of limbs of U254 since we are adding two numbers
 const INPUT_SIZE: usize = 2 * U254::N_LIMBS;
+/// Output size is the number of limbs of U254
 const OUTPUT_SIZE: usize = U254::N_LIMBS;
 
-impl SplitableScript<IOType, IOType, { INPUT_SIZE }, { OUTPUT_SIZE }> for U254AddScript {
+impl SplitableScript<{ INPUT_SIZE }, { OUTPUT_SIZE }> for U254AddScript {
     fn script() -> Script {
         U254::OP_ADD(1, 0)
     }
 
-    fn generate_valid_io_pair() -> IOPair<IOType, IOType, { INPUT_SIZE }, { OUTPUT_SIZE }> {
+    fn generate_valid_io_pair() -> IOPair<{ INPUT_SIZE }, { OUTPUT_SIZE }> {
         let mut prng = ChaCha20Rng::seed_from_u64(0);
 
-        let a: BigUint = prng.sample(RandomBits::new(254));
-        let b: BigUint = prng.sample(RandomBits::new(254));
-        let c: BigUint = (a.clone() + b.clone()).rem(BigUint::one().shl(254));
-
-        // Input is simply a and b limbs concatenated
-        let mut input = a.to_u32_digits().clone();
-        input.append(&mut b.to_u32_digits());
-
-        // Output is limbs of c
-        let output = c.to_u32_digits();
+        let num_1: BigUint = prng.sample(RandomBits::new(254));
+        let num_2: BigUint = prng.sample(RandomBits::new(254));
+        let sum: BigUint = (num_1.clone() + num_2.clone()).rem(BigUint::one().shl(254));
 
         IOPair {
-            input: input.try_into().expect("Input is not of the correct size"),
-            output: output
-                .try_into()
-                .expect("Output is not of the correct size"),
+            input: script! {
+                { U254::OP_PUSH_U32LESLICE(&num_1.to_u32_digits()) }
+                { U254::OP_PUSH_U32LESLICE(&num_2.to_u32_digits()) }
+            },
+            output: U254::OP_PUSH_U32LESLICE(&sum.to_u32_digits()),
         }
     }
 }

From 629e45ff35f929900425d85c126712e510a1bd53 Mon Sep 17 00:00:00 2001
From: ZamDimon <zamdmytro@gmail.com>
Date: Mon, 16 Sep 2024 15:34:50 +0300
Subject: [PATCH 05/17] :sparkles: add multiplication script

---
 splitter/src/test_scripts/int_add.rs |  5 ++-
 splitter/src/test_scripts/int_mul.rs | 57 ++++++++++++++++++++++++++--
 2 files changed, 58 insertions(+), 4 deletions(-)

diff --git a/splitter/src/test_scripts/int_add.rs b/splitter/src/test_scripts/int_add.rs
index 62903ba..b33ed41 100644
--- a/splitter/src/test_scripts/int_add.rs
+++ b/splitter/src/test_scripts/int_add.rs
@@ -1,5 +1,6 @@
 //! This module contains the test script
-//! for performing the addition of two large integers (exceeding standard Bitcoin 31-bit integers)
+//! for performing the addition of two large integers 
+//! (exceeding standard Bitcoin 31-bit integers)
 
 use crate::{
     split::script::{IOPair, SplitableScript},
@@ -22,6 +23,7 @@ use rand_chacha::ChaCha20Rng;
 /// Script that performs the addition of two 254-bit numbers
 pub struct U254AddScript;
 
+
 /// Input size is double the number of limbs of U254 since we are adding two numbers
 const INPUT_SIZE: usize = 2 * U254::N_LIMBS;
 /// Output size is the number of limbs of U254
@@ -35,6 +37,7 @@ impl SplitableScript<{ INPUT_SIZE }, { OUTPUT_SIZE }> for U254AddScript {
     fn generate_valid_io_pair() -> IOPair<{ INPUT_SIZE }, { OUTPUT_SIZE }> {
         let mut prng = ChaCha20Rng::seed_from_u64(0);
 
+        // Generate two random 254-bit numbers and calculate their sum
         let num_1: BigUint = prng.sample(RandomBits::new(254));
         let num_2: BigUint = prng.sample(RandomBits::new(254));
         let sum: BigUint = (num_1.clone() + num_2.clone()).rem(BigUint::one().shl(254));
diff --git a/splitter/src/test_scripts/int_mul.rs b/splitter/src/test_scripts/int_mul.rs
index 101c7e4..a462c19 100644
--- a/splitter/src/test_scripts/int_mul.rs
+++ b/splitter/src/test_scripts/int_mul.rs
@@ -1,5 +1,56 @@
 //! This module contains the test script
-//! for performing the multiplication of two large integers (exceeding standard Bitcoin 31-bit integers)
+//! for performing the multiplication of two large integers 
+//! (exceeding standard Bitcoin 31-bit integers)
 
-#[allow(unused_imports)]
-use crate::treepp::*;
+use crate::{
+    split::script::{IOPair, SplitableScript},
+    treepp::*,
+};
+use bitcoin_window_mul::{
+    bigint::{U254Windowed, U508}, traits::integer::{NonNativeInteger, NonNativeLimbInteger},
+};
+
+use num_bigint::{BigUint, RandomBits};
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha20Rng;
+
+/// Script that performs the addition of two 254-bit numbers
+pub struct U254MulScript;
+
+/// Input size is double the number of limbs of U254 since we are multiplying two numbers
+const INPUT_SIZE: usize = 2 * U254Windowed::N_LIMBS;
+/// Output size is the number of limbs of U508
+const OUTPUT_SIZE: usize = U508::N_LIMBS;
+
+impl SplitableScript<{ INPUT_SIZE }, { OUTPUT_SIZE }> for U254MulScript {
+    fn script() -> Script {
+        U254Windowed::OP_WIDENINGMUL::<U508>() 
+    }
+
+    fn generate_valid_io_pair() -> IOPair<{ INPUT_SIZE }, { OUTPUT_SIZE }> {
+        let mut prng = ChaCha20Rng::seed_from_u64(0);
+
+        // Generate two random 254-bit numbers and calculate their sum
+        let num_1: BigUint = prng.sample(RandomBits::new(254));
+        let num_2: BigUint = prng.sample(RandomBits::new(254));
+        let product: BigUint = num_1.clone() * num_2.clone();
+
+        IOPair {
+            input: script! {
+                { U254Windowed::OP_PUSH_U32LESLICE(&num_1.to_u32_digits()) }
+                { U254Windowed::OP_PUSH_U32LESLICE(&num_2.to_u32_digits()) }
+            },
+            output: U508::OP_PUSH_U32LESLICE(&product.to_u32_digits()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_verify() {
+        assert!(U254MulScript::verify_random());
+    }
+}

From 271cb301b2b625cad1e22f4cf71aa43fbe837d42 Mon Sep 17 00:00:00 2001
From: ZamDimon <zamdmytro@gmail.com>
Date: Mon, 16 Sep 2024 16:15:04 +0300
Subject: [PATCH 06/17] :construction: wip, attempt to implement naive split

---
 splitter/src/split/core.rs           | 54 ++++++++++++++++++++++++++++
 splitter/src/split/mod.rs            |  1 +
 splitter/src/split/script.rs         |  7 ++++
 splitter/src/test_scripts/int_mul.rs | 10 ++++++
 4 files changed, 72 insertions(+)
 create mode 100644 splitter/src/split/core.rs

diff --git a/splitter/src/split/core.rs b/splitter/src/split/core.rs
new file mode 100644
index 0000000..7dd0f6c
--- /dev/null
+++ b/splitter/src/split/core.rs
@@ -0,0 +1,54 @@
+//! Module containing the logic of splitting the script into smaller parts
+
+use bitcoin::script::{Instruction, Instructions, PushBytes};
+
+use crate::treepp::*;
+
+/// Maximum size of the script in bytes
+pub(super) const MAX_SCRIPT_SIZE: usize = 30000;
+
+pub struct SplitResult {
+    /// Scripts that constitute the input script
+    pub scripts: Vec<Script>, 
+    /// Scripts that contain intermediate results
+    pub intermediate_results: Vec<Script>,
+}
+
+/// Splits the given script into smaller parts
+fn split_into_chunks(instructions: Instructions) -> Vec<Script> {
+    let intructions: Vec<Instruction> = instructions
+        .into_iter()
+        .map(|x| x.expect("intructions are corrupted"))
+        .collect();
+
+    println!("Instructions: {:?}", intructions.len());
+    
+    intructions.chunks(MAX_SCRIPT_SIZE).map(|chunk| {
+        println!("Chunk: {:?}", chunk.len());
+
+        let num_opcodes = chunk.iter().filter(|x| matches!(x, Instruction::Op(_))).count();
+        let num_pushes = chunk.iter().filter(|x| matches!(x, Instruction::PushBytes(_))).count();
+
+        println!("Opcodes: {}, Pushes: {}", num_opcodes, num_pushes);
+
+        script! {
+            for instruction in chunk {
+                if let Instruction::Op(op) = instruction {
+                    { op.to_u8() }
+                }
+                else if let Instruction::PushBytes(bytes) = instruction {
+                    { PushBytes::as_bytes(*bytes).to_vec() }
+                }
+            }
+        }
+    }).collect()
+}
+
+pub(super) fn naive_split(script: Script) -> SplitResult {
+    let scripts = split_into_chunks(script.instructions());
+    
+    SplitResult {
+        scripts,
+        intermediate_results: vec![],
+    }
+}
diff --git a/splitter/src/split/mod.rs b/splitter/src/split/mod.rs
index 065720b..fd8ba4b 100644
--- a/splitter/src/split/mod.rs
+++ b/splitter/src/split/mod.rs
@@ -2,3 +2,4 @@
 //! together with all auxiliary functions and data structures.
 
 pub mod script;
+pub mod core;
diff --git a/splitter/src/split/script.rs b/splitter/src/split/script.rs
index c60bb56..a5d7bd9 100644
--- a/splitter/src/split/script.rs
+++ b/splitter/src/split/script.rs
@@ -2,6 +2,8 @@
 
 use crate::treepp::*;
 
+use super::core::{naive_split, SplitResult};
+
 /// Structure that represents a pair of input and output scripts. Typically, the prover
 /// wants to prove `script(input) == output`
 pub struct IOPair<const INPUT_SIZE: usize, const OUTPUT_SIZE: usize> {
@@ -47,4 +49,9 @@ pub trait SplitableScript<const INPUT_SIZE: usize, const OUTPUT_SIZE: usize> {
         let IOPair { input, output } = Self::generate_valid_io_pair();
         Self::verify(input, output)
     }
+
+    /// Splits the script into smaller parts
+    fn split() -> SplitResult {
+        naive_split(Self::script())
+    }
 }
diff --git a/splitter/src/test_scripts/int_mul.rs b/splitter/src/test_scripts/int_mul.rs
index a462c19..4910a49 100644
--- a/splitter/src/test_scripts/int_mul.rs
+++ b/splitter/src/test_scripts/int_mul.rs
@@ -53,4 +53,14 @@ mod tests {
     fn test_verify() {
         assert!(U254MulScript::verify_random());
     }
+
+    #[test]
+    fn test_split() {
+        println!("{}", U254Windowed::OP_WIDENINGMUL::<U508>().len());
+
+        let split_result = U254MulScript::split();
+        for script in split_result.scripts {
+            println!("{}", script.len());
+        }
+    }
 }

From 3d38ae39bb313ed041f2dc41983bfd83973a0ded Mon Sep 17 00:00:00 2001
From: ZamDimon <zamdmytro@gmail.com>
Date: Tue, 17 Sep 2024 11:18:54 +0300
Subject: [PATCH 07/17] :construction: wip, more experimentation

---
 splitter/src/debug.rs                | 123 ++++++++-------------------
 splitter/src/lib.rs                  |  25 +++++-
 splitter/src/split/core.rs           | 117 ++++++++++++++++---------
 splitter/src/split/mod.rs            |   2 +-
 splitter/src/split/script.rs         |  21 ++++-
 splitter/src/test_scripts/int_add.rs |   3 +-
 splitter/src/test_scripts/int_mul.rs |  21 +++--
 7 files changed, 172 insertions(+), 140 deletions(-)

diff --git a/splitter/src/debug.rs b/splitter/src/debug.rs
index 3584b1e..3bb183f 100644
--- a/splitter/src/debug.rs
+++ b/splitter/src/debug.rs
@@ -1,58 +1,19 @@
-use bitcoin::{hashes::Hash, hex::DisplayHex, Opcode, TapLeafHash, Transaction};
+use bitcoin::{hashes::Hash, ScriptBuf, TapLeafHash, Transaction};
 use bitcoin_scriptexec::{Exec, ExecCtx, ExecError, ExecStats, Options, Stack, TxTemplate};
 use core::fmt;
 
-/// A wrapper for the stack types to print them better.
-pub struct FmtStack(Stack);
-impl fmt::Display for FmtStack {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut iter = self.0.iter_str().enumerate().peekable();
-        write!(f, "\n0:\t\t ")?;
-        while let Some((index, item)) = iter.next() {
-            write!(f, "0x{:8}", item.as_hex())?;
-            if iter.peek().is_some() {
-                if (index + 1) % f.width().unwrap() == 0 {
-                    write!(f, "\n{}:\t\t", index + 1)?;
-                }
-                write!(f, " ")?;
-            }
-        }
-        Ok(())
-    }
-}
-
-impl FmtStack {
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-
-    pub fn get(&self, index: usize) -> Vec<u8> {
-        self.0.get(index)
-    }
-}
-
-impl fmt::Debug for FmtStack {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self)?;
-        Ok(())
-    }
-}
-
+/// Information about the status of the script execution.
 #[derive(Debug)]
 pub struct ExecuteInfo {
     pub success: bool,
     pub error: Option<ExecError>,
-    pub final_stack: FmtStack,
-    pub remaining_script: String,
-    pub last_opcode: Option<Opcode>,
+    pub main_stack: Stack,
+    pub alt_stack: Stack,
     pub stats: ExecStats,
 }
 
 impl fmt::Display for ExecuteInfo {
+    /// Formats the `ExecuteInfo` struct for display.
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if self.success {
             writeln!(f, "Script execution successful.")?;
@@ -62,26 +23,15 @@ impl fmt::Display for ExecuteInfo {
         if let Some(ref error) = self.error {
             writeln!(f, "Error: {:?}", error)?;
         }
-        if !self.remaining_script.is_empty() {
-            writeln!(f, "Remaining Script: {}", self.remaining_script)?;
-        }
-        if !self.final_stack.is_empty() {
-            match f.width() {
-                None => writeln!(f, "Final Stack: {:4}", self.final_stack)?,
-                Some(width) => {
-                    writeln!(f, "Final Stack: {:width$}", self.final_stack, width = width)?
-                }
-            }
-        }
-        if let Some(ref opcode) = self.last_opcode {
-            writeln!(f, "Last Opcode: {:?}", opcode)?;
-        }
+
         writeln!(f, "Stats: {:?}", self.stats)?;
         Ok(())
     }
 }
 
-pub fn execute_script(script: bitcoin::ScriptBuf) -> ExecuteInfo {
+/// Executes the given script and returns the result of the execution
+/// (success, error, stack, etc.)
+pub fn execute_script(script: ScriptBuf) -> ExecuteInfo {
     let mut exec = Exec::new(
         ExecCtx::Tapscript,
         Options::default(),
@@ -99,34 +49,31 @@ pub fn execute_script(script: bitcoin::ScriptBuf) -> ExecuteInfo {
         script,
         vec![],
     )
-    .expect("error creating exec");
-
+    .expect("error when creating the execution body");
+    
+    // Execute all the opcodes while possible
     loop {
         if exec.exec_next().is_err() {
             break;
         }
     }
-    let res = exec.result().unwrap();
-    ExecuteInfo {
-        success: res.success,
-        error: res.error.clone(),
-        last_opcode: res.opcode,
-        final_stack: FmtStack(exec.stack().clone()),
-        remaining_script: exec.remaining_script().to_asm_string(),
+    
+    // Obtaining the result of the execution
+    let result = exec.result().unwrap();
+    
+    ExecuteInfo { 
+        success: result.success,
+        error: result.error.clone(),
+        main_stack: exec.stack().clone(),
+        alt_stack: exec.altstack().clone(),
         stats: exec.stats().clone(),
     }
 }
 
-/// Prints the size of the script in bytes.
-#[allow(dead_code)]
-pub fn print_script_size(name: &str, script: bitcoin::ScriptBuf) {
-    println!("{} script is {} bytes in size", name, script.len());
-}
-
-// Execute a script on stack without `MAX_STACK_SIZE` limit.
-// This function is only used for script test, not for production.
-//
-// NOTE: Only for test purposes.
+/// Execute a script on stack without `MAX_STACK_SIZE` limit.
+/// This function is only used for script test, not for production.
+///
+/// NOTE: Only for test purposes.
 #[allow(dead_code)]
 pub fn execute_script_no_stack_limit(script: bitcoin::ScriptBuf) -> ExecuteInfo {
     // Get the default options for the script exec.
@@ -153,20 +100,23 @@ pub fn execute_script_no_stack_limit(script: bitcoin::ScriptBuf) -> ExecuteInfo
         script,
         vec![],
     )
-    .expect("error creating exec");
+    .expect("error while creating the execution body");
 
+    // Execute all the opcodes while possible
     loop {
         if exec.exec_next().is_err() {
             break;
         }
     }
-    let res = exec.result().unwrap();
-    ExecuteInfo {
-        success: res.success,
-        error: res.error.clone(),
-        last_opcode: res.opcode,
-        final_stack: FmtStack(exec.stack().clone()),
-        remaining_script: exec.remaining_script().to_asm_string(),
+
+    // Get the result of the execution
+    let result = exec.result().unwrap();
+
+    ExecuteInfo { 
+        success: result.success,
+        error: result.error.clone(),
+        main_stack: exec.stack().clone(),
+        alt_stack: exec.altstack().clone(),
         stats: exec.stats().clone(),
     }
 }
@@ -199,6 +149,7 @@ mod test {
             }
             OP_1
         };
+
         let exec_result = execute_script_no_stack_limit(script);
         assert!(exec_result.success);
     }
diff --git a/splitter/src/lib.rs b/splitter/src/lib.rs
index ae7e007..c733eab 100644
--- a/splitter/src/lib.rs
+++ b/splitter/src/lib.rs
@@ -14,11 +14,13 @@ pub(crate) mod test_scripts;
 
 #[cfg(test)]
 mod tests {
+    use std::io::Read;
+
     use super::treepp::*;
 
     /// Tests that checks that environment was set up correctly by running a 2+3=5 script.
     #[test]
-    fn test_healthy_check() {
+    fn test_healthy_check_1() {
         let script = script! {
             2 3 OP_ADD 5 OP_EQUAL
         };
@@ -28,4 +30,25 @@ mod tests {
 
         println!("Environment is set up correctly!");
     }
+
+    /// Tests that checks that environment was set up correctly by running a 2+3=5 script.
+    #[test]
+    fn test_healthy_check_2() {
+        let script_1 = script! {
+            13123 1235 OP_ADD 4234 OP_ADD
+        };
+        println!("Script 1 stack: {:?}", script_1.to_asm_string());
+
+        let exec_result_1 = execute_script(script_1);
+
+        let script_2 = script! {
+            { exec_result_1.main_stack.get(0) }
+            3 OP_ADD 18595 OP_EQUAL
+        };
+
+        println!("Script 2 stack: {:?}", script_2.to_asm_string());
+
+        let exec_result_2 = execute_script(script_2);
+        assert!(exec_result_2.success);
+    }
 }
diff --git a/splitter/src/split/core.rs b/splitter/src/split/core.rs
index 7dd0f6c..99ff187 100644
--- a/splitter/src/split/core.rs
+++ b/splitter/src/split/core.rs
@@ -1,54 +1,91 @@
 //! Module containing the logic of splitting the script into smaller parts
 
-use bitcoin::script::{Instruction, Instructions, PushBytes};
-
-use crate::treepp::*;
+use crate::{split::script::IntermediateResult, treepp::*};
+use super::script::SplitResult;
 
 /// Maximum size of the script in bytes
 pub(super) const MAX_SCRIPT_SIZE: usize = 30000;
 
-pub struct SplitResult {
-    /// Scripts that constitute the input script
-    pub scripts: Vec<Script>, 
-    /// Scripts that contain intermediate results
-    pub intermediate_results: Vec<Script>,
+/// Splits the given script into smaller parts
+fn split_into_shards(script: Script) -> Vec<Script> {
+    script
+        .as_bytes()
+        .chunks(MAX_SCRIPT_SIZE)
+        .map(|chunk| {
+            script! {
+                { chunk.to_vec() }
+            }
+        })
+        .collect()
 }
 
-/// Splits the given script into smaller parts
-fn split_into_chunks(instructions: Instructions) -> Vec<Script> {
-    let intructions: Vec<Instruction> = instructions
-        .into_iter()
-        .map(|x| x.expect("intructions are corrupted"))
-        .collect();
-
-    println!("Instructions: {:?}", intructions.len());
-    
-    intructions.chunks(MAX_SCRIPT_SIZE).map(|chunk| {
-        println!("Chunk: {:?}", chunk.len());
-
-        let num_opcodes = chunk.iter().filter(|x| matches!(x, Instruction::Op(_))).count();
-        let num_pushes = chunk.iter().filter(|x| matches!(x, Instruction::PushBytes(_))).count();
-
-        println!("Opcodes: {}, Pushes: {}", num_opcodes, num_pushes);
-
-        script! {
-            for instruction in chunk {
-                if let Instruction::Op(op) = instruction {
-                    { op.to_u8() }
-                }
-                else if let Instruction::PushBytes(bytes) = instruction {
-                    { PushBytes::as_bytes(*bytes).to_vec() }
+pub(super) fn naive_split(input: Script, script: Script) -> SplitResult {
+    // First, we split the script into smaller parts
+    let shards = split_into_shards(script);
+    let mut intermediate_results: Vec<IntermediateResult> = vec![];
+
+    // Then, we do the following steps:
+    // 1. We execute the first script with the input
+    // 2. We take the stack and write it to the intermediate results
+    // 3. We execute the second script with the saved intermediate results
+    // 4. Take the stask, save to the intermediate results
+    // 5. Repeat until the last script
+    let first_shard_script = script! {
+        { input }
+        { shards[0].clone() }
+    };
+    let result = execute_script(first_shard_script);
+    intermediate_results.push(IntermediateResult{
+        stack: result.main_stack.clone(),
+        altstack: result.alt_stack.clone(),
+    });
+    println!("Intermediate lengths: {:?} + {:?}", result.main_stack.len(), result.alt_stack.len());
+
+    for shard in shards.clone().into_iter().skip(1) {
+        // Executing a piece of the script with the current input.
+        // NOTE #1: unwrap is safe to use here since intermediate_results is of length 1.
+        // NOTE #2: we need to feed in both the stack and the altstack
+
+        let current_input = intermediate_results.last().unwrap();
+        let IntermediateResult{stack, altstack} = current_input;
+
+        println!("Stack lengths: {:?} + {:?}", stack.len(), altstack.len());
+
+        let temporary_script = script! {
+            // Pushing main stack
+            if stack.len() > 0 {
+                { stack.get(0) }
+            }
+
+            // Pushing alt stack
+            if altstack.len() > 0 {
+                { altstack.get(0) }
+                for _ in 0..altstack.len() {
+                    OP_TOALTSTACK
                 }
             }
-        }
-    }).collect()
-}
 
-pub(super) fn naive_split(script: Script) -> SplitResult {
-    let scripts = split_into_chunks(script.instructions());
-    
+            // Pushing the current shard
+            { shard.clone() }
+        };
+
+        let result = execute_script(temporary_script);
+        intermediate_results.push(IntermediateResult{
+            stack: result.main_stack.clone(),
+            altstack: result.alt_stack.clone(),
+        });
+
+        println!("Stack lengths: {:?} + {:?}", result.main_stack.len(), result.alt_stack.len());
+    }
+
+    assert_eq!(
+        intermediate_results.len(),
+        shards.len(),
+        "Intermediate results should be the same as the number of scripts"
+    );
+
     SplitResult {
-        scripts,
-        intermediate_results: vec![],
+        shards,
+        intermediate_results,
     }
 }
diff --git a/splitter/src/split/mod.rs b/splitter/src/split/mod.rs
index fd8ba4b..a13a255 100644
--- a/splitter/src/split/mod.rs
+++ b/splitter/src/split/mod.rs
@@ -1,5 +1,5 @@
 //! Module that contains the implementation of the splitter
 //! together with all auxiliary functions and data structures.
 
-pub mod script;
 pub mod core;
+pub mod script;
diff --git a/splitter/src/split/script.rs b/splitter/src/split/script.rs
index a5d7bd9..f39d323 100644
--- a/splitter/src/split/script.rs
+++ b/splitter/src/split/script.rs
@@ -1,8 +1,10 @@
 //! Module containing the structure for scripts that we are going to use
 
+use bitcoin_scriptexec::Stack;
+
 use crate::treepp::*;
 
-use super::core::{naive_split, SplitResult};
+use super::core::naive_split;
 
 /// Structure that represents a pair of input and output scripts. Typically, the prover
 /// wants to prove `script(input) == output`
@@ -13,6 +15,19 @@ pub struct IOPair<const INPUT_SIZE: usize, const OUTPUT_SIZE: usize> {
     pub output: Script,
 }
 
+pub struct IntermediateResult {
+    pub stack: Stack,
+    pub altstack: Stack,
+}
+
+/// Structure that represents the result of splitting a script
+pub struct SplitResult {
+    /// Scripts (shards) that constitute the input script
+    pub shards: Vec<Script>,
+    /// Scripts that contain intermediate results (z values in the paper)
+    pub intermediate_results: Vec<IntermediateResult>,
+}
+
 /// Trait that any script that can be split should implement
 pub trait SplitableScript<const INPUT_SIZE: usize, const OUTPUT_SIZE: usize> {
     /// Returns the main logic (f) of the script
@@ -51,7 +66,7 @@ pub trait SplitableScript<const INPUT_SIZE: usize, const OUTPUT_SIZE: usize> {
     }
 
     /// Splits the script into smaller parts
-    fn split() -> SplitResult {
-        naive_split(Self::script())
+    fn split(input: Script) -> SplitResult {
+        naive_split(input, Self::script())
     }
 }
diff --git a/splitter/src/test_scripts/int_add.rs b/splitter/src/test_scripts/int_add.rs
index b33ed41..a816f98 100644
--- a/splitter/src/test_scripts/int_add.rs
+++ b/splitter/src/test_scripts/int_add.rs
@@ -1,5 +1,5 @@
 //! This module contains the test script
-//! for performing the addition of two large integers 
+//! for performing the addition of two large integers
 //! (exceeding standard Bitcoin 31-bit integers)
 
 use crate::{
@@ -23,7 +23,6 @@ use rand_chacha::ChaCha20Rng;
 /// Script that performs the addition of two 254-bit numbers
 pub struct U254AddScript;
 
-
 /// Input size is double the number of limbs of U254 since we are adding two numbers
 const INPUT_SIZE: usize = 2 * U254::N_LIMBS;
 /// Output size is the number of limbs of U254
diff --git a/splitter/src/test_scripts/int_mul.rs b/splitter/src/test_scripts/int_mul.rs
index 4910a49..4acd039 100644
--- a/splitter/src/test_scripts/int_mul.rs
+++ b/splitter/src/test_scripts/int_mul.rs
@@ -1,5 +1,5 @@
 //! This module contains the test script
-//! for performing the multiplication of two large integers 
+//! for performing the multiplication of two large integers
 //! (exceeding standard Bitcoin 31-bit integers)
 
 use crate::{
@@ -7,7 +7,8 @@ use crate::{
     treepp::*,
 };
 use bitcoin_window_mul::{
-    bigint::{U254Windowed, U508}, traits::integer::{NonNativeInteger, NonNativeLimbInteger},
+    bigint::{U254Windowed, U508},
+    traits::integer::{NonNativeInteger, NonNativeLimbInteger},
 };
 
 use num_bigint::{BigUint, RandomBits};
@@ -24,7 +25,7 @@ const OUTPUT_SIZE: usize = U508::N_LIMBS;
 
 impl SplitableScript<{ INPUT_SIZE }, { OUTPUT_SIZE }> for U254MulScript {
     fn script() -> Script {
-        U254Windowed::OP_WIDENINGMUL::<U508>() 
+        U254Windowed::OP_WIDENINGMUL::<U508>()
     }
 
     fn generate_valid_io_pair() -> IOPair<{ INPUT_SIZE }, { OUTPUT_SIZE }> {
@@ -56,11 +57,17 @@ mod tests {
 
     #[test]
     fn test_split() {
-        println!("{}", U254Windowed::OP_WIDENINGMUL::<U508>().len());
+        // First, we generate the pair of input and output scripts
+        let IOPair { input, output } = U254MulScript::generate_valid_io_pair();
 
-        let split_result = U254MulScript::split();
-        for script in split_result.scripts {
-            println!("{}", script.len());
+        let split_result = U254MulScript::split(input);
+        for shard in split_result.shards {
+            println!("Shard is of length {}", shard.len());
+        }
+
+        println!("Intermediate results:");
+        for intermediate_result in split_result.intermediate_results {
+            println!("Intermediate results: {};{}", intermediate_result.stack.len(), intermediate_result.altstack.len());
         }
     }
 }

From 7da025b3b5a41649c6d4f3cc82ee1830730c8dc4 Mon Sep 17 00:00:00 2001
From: ZamDimon <zamdmytro@gmail.com>
Date: Tue, 17 Sep 2024 13:54:29 +0300
Subject: [PATCH 08/17] :tada: finalize basic script split

---
 splitter/src/debug.rs                    | 10 +--
 splitter/src/lib.rs                      | 25 +------
 splitter/src/split/core.rs               | 86 +++++++++---------------
 splitter/src/split/intermediate_state.rs | 53 +++++++++++++++
 splitter/src/split/mod.rs                |  4 ++
 splitter/src/split/script.rs             | 14 +---
 splitter/src/split/tests.rs              | 41 +++++++++++
 splitter/src/test_scripts/int_mul.rs     |  8 ++-
 8 files changed, 146 insertions(+), 95 deletions(-)
 create mode 100644 splitter/src/split/intermediate_state.rs
 create mode 100644 splitter/src/split/tests.rs

diff --git a/splitter/src/debug.rs b/splitter/src/debug.rs
index 3bb183f..5ec2a0c 100644
--- a/splitter/src/debug.rs
+++ b/splitter/src/debug.rs
@@ -50,18 +50,18 @@ pub fn execute_script(script: ScriptBuf) -> ExecuteInfo {
         vec![],
     )
     .expect("error when creating the execution body");
-    
+
     // Execute all the opcodes while possible
     loop {
         if exec.exec_next().is_err() {
             break;
         }
     }
-    
+
     // Obtaining the result of the execution
     let result = exec.result().unwrap();
-    
-    ExecuteInfo { 
+
+    ExecuteInfo {
         success: result.success,
         error: result.error.clone(),
         main_stack: exec.stack().clone(),
@@ -112,7 +112,7 @@ pub fn execute_script_no_stack_limit(script: bitcoin::ScriptBuf) -> ExecuteInfo
     // Get the result of the execution
     let result = exec.result().unwrap();
 
-    ExecuteInfo { 
+    ExecuteInfo {
         success: result.success,
         error: result.error.clone(),
         main_stack: exec.stack().clone(),
diff --git a/splitter/src/lib.rs b/splitter/src/lib.rs
index c733eab..ae7e007 100644
--- a/splitter/src/lib.rs
+++ b/splitter/src/lib.rs
@@ -14,13 +14,11 @@ pub(crate) mod test_scripts;
 
 #[cfg(test)]
 mod tests {
-    use std::io::Read;
-
     use super::treepp::*;
 
     /// Tests that checks that environment was set up correctly by running a 2+3=5 script.
     #[test]
-    fn test_healthy_check_1() {
+    fn test_healthy_check() {
         let script = script! {
             2 3 OP_ADD 5 OP_EQUAL
         };
@@ -30,25 +28,4 @@ mod tests {
 
         println!("Environment is set up correctly!");
     }
-
-    /// Tests that checks that environment was set up correctly by running a 2+3=5 script.
-    #[test]
-    fn test_healthy_check_2() {
-        let script_1 = script! {
-            13123 1235 OP_ADD 4234 OP_ADD
-        };
-        println!("Script 1 stack: {:?}", script_1.to_asm_string());
-
-        let exec_result_1 = execute_script(script_1);
-
-        let script_2 = script! {
-            { exec_result_1.main_stack.get(0) }
-            3 OP_ADD 18595 OP_EQUAL
-        };
-
-        println!("Script 2 stack: {:?}", script_2.to_asm_string());
-
-        let exec_result_2 = execute_script(script_2);
-        assert!(exec_result_2.success);
-    }
 }
diff --git a/splitter/src/split/core.rs b/splitter/src/split/core.rs
index 99ff187..bec20c8 100644
--- a/splitter/src/split/core.rs
+++ b/splitter/src/split/core.rs
@@ -1,28 +1,43 @@
 //! Module containing the logic of splitting the script into smaller parts
 
-use crate::{split::script::IntermediateResult, treepp::*};
+use bitcoin::script::Instruction;
+
 use super::script::SplitResult;
+use crate::{split::intermediate_state::IntermediateState, treepp::*};
 
 /// Maximum size of the script in bytes
 pub(super) const MAX_SCRIPT_SIZE: usize = 30000;
 
 /// Splits the given script into smaller parts
-fn split_into_shards(script: Script) -> Vec<Script> {
-    script
-        .as_bytes()
-        .chunks(MAX_SCRIPT_SIZE)
+pub(super) fn split_into_shards(script: &Script, chunk_size: usize) -> Vec<Script> {
+    let instructions: Vec<Instruction> = script
+        .instructions()
+        .map(|instruction| {
+            let instruction = instruction.expect("script is most likely corrupted");
+            instruction
+        }).collect();
+    
+    instructions
+        .chunks(chunk_size)
         .map(|chunk| {
-            script! {
-                { chunk.to_vec() }
+            for instruction in chunk {
+                println!("{:?}", instruction);
+            }
+
+            let mut shard = Script::new();
+            for instruction in chunk {
+                shard.push_instruction(instruction.clone());
             }
+
+            shard
         })
         .collect()
 }
 
 pub(super) fn naive_split(input: Script, script: Script) -> SplitResult {
     // First, we split the script into smaller parts
-    let shards = split_into_shards(script);
-    let mut intermediate_results: Vec<IntermediateResult> = vec![];
+    let shards = split_into_shards(&script, MAX_SCRIPT_SIZE);
+    let mut intermediate_states: Vec<IntermediateState> = vec![];
 
     // Then, we do the following steps:
     // 1. We execute the first script with the input
@@ -30,62 +45,27 @@ pub(super) fn naive_split(input: Script, script: Script) -> SplitResult {
     // 3. We execute the second script with the saved intermediate results
     // 4. Take the stask, save to the intermediate results
     // 5. Repeat until the last script
-    let first_shard_script = script! {
-        { input }
-        { shards[0].clone() }
-    };
-    let result = execute_script(first_shard_script);
-    intermediate_results.push(IntermediateResult{
-        stack: result.main_stack.clone(),
-        altstack: result.alt_stack.clone(),
-    });
-    println!("Intermediate lengths: {:?} + {:?}", result.main_stack.len(), result.alt_stack.len());
+
+    intermediate_states.push(IntermediateState::from_input_script(&input, &shards[0]));
 
     for shard in shards.clone().into_iter().skip(1) {
         // Executing a piece of the script with the current input.
-        // NOTE #1: unwrap is safe to use here since intermediate_results is of length 1.
+        // NOTE #1: unwrap is safe to use here since intermediate_states is of length 1.
         // NOTE #2: we need to feed in both the stack and the altstack
 
-        let current_input = intermediate_results.last().unwrap();
-        let IntermediateResult{stack, altstack} = current_input;
-
-        println!("Stack lengths: {:?} + {:?}", stack.len(), altstack.len());
-
-        let temporary_script = script! {
-            // Pushing main stack
-            if stack.len() > 0 {
-                { stack.get(0) }
-            }
-
-            // Pushing alt stack
-            if altstack.len() > 0 {
-                { altstack.get(0) }
-                for _ in 0..altstack.len() {
-                    OP_TOALTSTACK
-                }
-            }
-
-            // Pushing the current shard
-            { shard.clone() }
-        };
-
-        let result = execute_script(temporary_script);
-        intermediate_results.push(IntermediateResult{
-            stack: result.main_stack.clone(),
-            altstack: result.alt_stack.clone(),
-        });
-
-        println!("Stack lengths: {:?} + {:?}", result.main_stack.len(), result.alt_stack.len());
+        intermediate_states.push(IntermediateState::from_intermediate_result(
+            intermediate_states.last().unwrap(),
+            &shard,
+        ));
     }
 
     assert_eq!(
-        intermediate_results.len(),
+        intermediate_states.len(),
         shards.len(),
         "Intermediate results should be the same as the number of scripts"
     );
-
     SplitResult {
         shards,
-        intermediate_results,
+        intermediate_states,
     }
 }
diff --git a/splitter/src/split/intermediate_state.rs b/splitter/src/split/intermediate_state.rs
new file mode 100644
index 0000000..435315f
--- /dev/null
+++ b/splitter/src/split/intermediate_state.rs
@@ -0,0 +1,53 @@
+//! This module contains the [`IntermediateState`] struct, which is used to store the intermediate
+//! state of the stack and altstack during the execution of a script split into the shards (subprograms).
+
+use crate::treepp::*;
+use bitcoin_scriptexec::Stack;
+
+pub struct IntermediateState {
+    pub stack: Stack,
+    pub altstack: Stack,
+}
+
+impl IntermediateState {
+    /// Executes the script with the given input and returns the intermediate result,
+    /// that is, the stack and altstack after the execution
+    pub fn from_input_script(input: &Script, script: &Script) -> Self {
+        let script = script! {
+            { input.clone() }
+            { script.clone() }
+        };
+
+        let result = execute_script(script);
+
+        Self {
+            stack: result.main_stack.clone(),
+            altstack: result.alt_stack.clone(),
+        }
+    }
+
+    /// Based on the previous intermediate result, executes the script with the stacks
+    /// and altstacks of the previous result and returns the new intermediate result
+    pub fn from_intermediate_result(result: &Self, script: &Script) -> Self {
+        let Self { stack, altstack } = result;
+
+        let insert_result_script = script! {
+            // Checks for length of the stack and altstack
+            // are used to avoid panic when referencing the first element
+            // of the stack or altstack (by using get(0) method)
+            if stack.len() > 0 {
+                { stack.get(0) }
+            }
+
+            if altstack.len() > 0 {
+                { altstack.get(0) }
+
+                for _ in 0..altstack.len() {
+                    OP_TOALTSTACK
+                }
+            }
+        };
+
+        Self::from_input_script(&insert_result_script, script)
+    }
+}
diff --git a/splitter/src/split/mod.rs b/splitter/src/split/mod.rs
index a13a255..88bbd64 100644
--- a/splitter/src/split/mod.rs
+++ b/splitter/src/split/mod.rs
@@ -2,4 +2,8 @@
 //! together with all auxiliary functions and data structures.
 
 pub mod core;
+pub mod intermediate_state;
 pub mod script;
+
+#[cfg(test)]
+pub mod tests;
diff --git a/splitter/src/split/script.rs b/splitter/src/split/script.rs
index f39d323..e681520 100644
--- a/splitter/src/split/script.rs
+++ b/splitter/src/split/script.rs
@@ -1,11 +1,8 @@
 //! Module containing the structure for scripts that we are going to use
 
-use bitcoin_scriptexec::Stack;
-
+use super::{core::naive_split, intermediate_state::IntermediateState};
 use crate::treepp::*;
 
-use super::core::naive_split;
-
 /// Structure that represents a pair of input and output scripts. Typically, the prover
 /// wants to prove `script(input) == output`
 pub struct IOPair<const INPUT_SIZE: usize, const OUTPUT_SIZE: usize> {
@@ -15,17 +12,12 @@ pub struct IOPair<const INPUT_SIZE: usize, const OUTPUT_SIZE: usize> {
     pub output: Script,
 }
 
-pub struct IntermediateResult {
-    pub stack: Stack,
-    pub altstack: Stack,
-}
-
 /// Structure that represents the result of splitting a script
 pub struct SplitResult {
     /// Scripts (shards) that constitute the input script
     pub shards: Vec<Script>,
-    /// Scripts that contain intermediate results (z values in the paper)
-    pub intermediate_results: Vec<IntermediateResult>,
+    /// Scripts that contain intermediate states (z values in the paper)
+    pub intermediate_states: Vec<IntermediateState>,
 }
 
 /// Trait that any script that can be split should implement
diff --git a/splitter/src/split/tests.rs b/splitter/src/split/tests.rs
new file mode 100644
index 0000000..62821ed
--- /dev/null
+++ b/splitter/src/split/tests.rs
@@ -0,0 +1,41 @@
+use crate::treepp::*;
+
+use super::core::split_into_shards;
+
+/// Tests whether splitting the script into subprograms (shards)
+/// works properly
+#[test]
+fn test_split() {
+    const CHUNK_SIZE: usize = 3;
+
+    // Adding a toy script to test the splitting
+    let test_script = script! {
+        {13123} {1235} OP_ADD {4234} OP_ADD {3} OP_ADD {18595} OP_EQUAL
+    };
+    println!("Initial script: {}", test_script.to_asm_string());
+
+    // Verifying its correctness 
+    let result = execute_script(test_script.clone());
+    assert!(result.success, "Test script failed");
+
+    let shards = split_into_shards(&test_script, CHUNK_SIZE);
+
+    // Asserting that we have three shards and each shard has at most three elements in the stack
+    assert_eq!(
+        shards.len(),
+        3,
+        "Shards number is incorrect"
+    );
+    for i in 0..3 {
+        println!("Shard {}: {}", i, shards[i].to_asm_string());
+    }
+
+    // Asserting that the shards are correct
+    let shard_1_script = script! {
+        { shards[0].clone() }
+        { 14358 }
+        OP_EQUAL
+    };
+    let shard_1_result = execute_script(shard_1_script);
+    assert!(shard_1_result.success, "Shard 1 failed");
+}
diff --git a/splitter/src/test_scripts/int_mul.rs b/splitter/src/test_scripts/int_mul.rs
index 4acd039..5a21be8 100644
--- a/splitter/src/test_scripts/int_mul.rs
+++ b/splitter/src/test_scripts/int_mul.rs
@@ -66,8 +66,12 @@ mod tests {
         }
 
         println!("Intermediate results:");
-        for intermediate_result in split_result.intermediate_results {
-            println!("Intermediate results: {};{}", intermediate_result.stack.len(), intermediate_result.altstack.len());
+        for intermediate_result in split_result.intermediate_states {
+            println!(
+                "Intermediate results: {};{}",
+                intermediate_result.stack.len(),
+                intermediate_result.altstack.len()
+            );
         }
     }
 }

From e1470f04e661681c57ae6fe96fb05afa39955970 Mon Sep 17 00:00:00 2001
From: ZamDimon <zamdmytro@gmail.com>
Date: Tue, 17 Sep 2024 14:01:33 +0300
Subject: [PATCH 09/17] :adhesive_bandage: small polishes to make CI happies

---
 splitter/src/split/core.rs               | 16 ++++++--------
 splitter/src/split/intermediate_state.rs |  4 ++--
 splitter/src/split/tests.rs              | 27 ++++++++++++++++++------
 splitter/src/test_scripts/int_mul.rs     |  5 ++++-
 4 files changed, 33 insertions(+), 19 deletions(-)

diff --git a/splitter/src/split/core.rs b/splitter/src/split/core.rs
index bec20c8..686ee82 100644
--- a/splitter/src/split/core.rs
+++ b/splitter/src/split/core.rs
@@ -8,25 +8,20 @@ use crate::{split::intermediate_state::IntermediateState, treepp::*};
 /// Maximum size of the script in bytes
 pub(super) const MAX_SCRIPT_SIZE: usize = 30000;
 
+// TODO: Currently, the chunk size splits the script into the parts of the same size IN TERMS OF INSTRUCTIONS, not bytes.
 /// Splits the given script into smaller parts
 pub(super) fn split_into_shards(script: &Script, chunk_size: usize) -> Vec<Script> {
     let instructions: Vec<Instruction> = script
         .instructions()
-        .map(|instruction| {
-            let instruction = instruction.expect("script is most likely corrupted");
-            instruction
-        }).collect();
-    
+        .map(|instruction| instruction.expect("script is most likely corrupted"))
+        .collect();
+
     instructions
         .chunks(chunk_size)
         .map(|chunk| {
-            for instruction in chunk {
-                println!("{:?}", instruction);
-            }
-
             let mut shard = Script::new();
             for instruction in chunk {
-                shard.push_instruction(instruction.clone());
+                shard.push_instruction(*instruction);
             }
 
             shard
@@ -64,6 +59,7 @@ pub(super) fn naive_split(input: Script, script: Script) -> SplitResult {
         shards.len(),
         "Intermediate results should be the same as the number of scripts"
     );
+
     SplitResult {
         shards,
         intermediate_states,
diff --git a/splitter/src/split/intermediate_state.rs b/splitter/src/split/intermediate_state.rs
index 435315f..e7412d1 100644
--- a/splitter/src/split/intermediate_state.rs
+++ b/splitter/src/split/intermediate_state.rs
@@ -35,11 +35,11 @@ impl IntermediateState {
             // Checks for length of the stack and altstack
             // are used to avoid panic when referencing the first element
             // of the stack or altstack (by using get(0) method)
-            if stack.len() > 0 {
+            if !stack.is_empty() {
                 { stack.get(0) }
             }
 
-            if altstack.len() > 0 {
+            if !altstack.is_empty() {
                 { altstack.get(0) }
 
                 for _ in 0..altstack.len() {
diff --git a/splitter/src/split/tests.rs b/splitter/src/split/tests.rs
index 62821ed..1f6a992 100644
--- a/splitter/src/split/tests.rs
+++ b/splitter/src/split/tests.rs
@@ -13,21 +13,20 @@ fn test_split() {
         {13123} {1235} OP_ADD {4234} OP_ADD {3} OP_ADD {18595} OP_EQUAL
     };
     println!("Initial script: {}", test_script.to_asm_string());
+    println!("Initial script size: {}", test_script.len());
 
-    // Verifying its correctness 
+    // Verifying its correctness
     let result = execute_script(test_script.clone());
     assert!(result.success, "Test script failed");
 
+    // Splitting the script into shards
     let shards = split_into_shards(&test_script, CHUNK_SIZE);
 
     // Asserting that we have three shards and each shard has at most three elements in the stack
-    assert_eq!(
-        shards.len(),
-        3,
-        "Shards number is incorrect"
-    );
+    assert_eq!(shards.len(), 3, "Shards number is incorrect");
     for i in 0..3 {
         println!("Shard {}: {}", i, shards[i].to_asm_string());
+        println!("Shard {} size: {}", i, shards[i].len());
     }
 
     // Asserting that the shards are correct
@@ -38,4 +37,20 @@ fn test_split() {
     };
     let shard_1_result = execute_script(shard_1_script);
     assert!(shard_1_result.success, "Shard 1 failed");
+
+    let shard_2_script = script! {
+        { 1 }
+        { shards[1].clone() }
+        OP_DROP
+        { 4235 }
+        OP_EQUAL
+    };
+    let shard_2_result = execute_script(shard_2_script);
+    assert!(shard_2_result.success, "Shard 2 failed");
+
+    let shard_3_result = execute_script(shards[2].clone());
+    assert!(
+        !shard_3_result.success,
+        "Shard 3 for somer reason succeeded"
+    );
 }
diff --git a/splitter/src/test_scripts/int_mul.rs b/splitter/src/test_scripts/int_mul.rs
index 5a21be8..c27465c 100644
--- a/splitter/src/test_scripts/int_mul.rs
+++ b/splitter/src/test_scripts/int_mul.rs
@@ -58,7 +58,10 @@ mod tests {
     #[test]
     fn test_split() {
         // First, we generate the pair of input and output scripts
-        let IOPair { input, output } = U254MulScript::generate_valid_io_pair();
+        let IOPair {
+            input,
+            output: _output,
+        } = U254MulScript::generate_valid_io_pair();
 
         let split_result = U254MulScript::split(input);
         for shard in split_result.shards {

From 793036e898812767f3935e6c64d957edd432664f Mon Sep 17 00:00:00 2001
From: ZamDimon <zamdmytro@gmail.com>
Date: Tue, 17 Sep 2024 17:04:11 +0300
Subject: [PATCH 10/17] :bug: getting closer

---
 splitter/src/debug.rs                    |   5 +-
 splitter/src/lib.rs                      |   4 +-
 splitter/src/split/intermediate_state.rs |   6 +-
 splitter/src/split/script.rs             |   3 +
 splitter/src/split/tests.rs              | 184 ++++++++++++++++++++++-
 splitter/src/utils.rs                    |  11 ++
 6 files changed, 204 insertions(+), 9 deletions(-)
 create mode 100644 splitter/src/utils.rs

diff --git a/splitter/src/debug.rs b/splitter/src/debug.rs
index 5ec2a0c..b48113a 100644
--- a/splitter/src/debug.rs
+++ b/splitter/src/debug.rs
@@ -34,7 +34,10 @@ impl fmt::Display for ExecuteInfo {
 pub fn execute_script(script: ScriptBuf) -> ExecuteInfo {
     let mut exec = Exec::new(
         ExecCtx::Tapscript,
-        Options::default(),
+        Options {
+            require_minimal: false,
+            ..Default::default()
+        },
         TxTemplate {
             tx: Transaction {
                 version: bitcoin::transaction::Version::TWO,
diff --git a/splitter/src/lib.rs b/splitter/src/lib.rs
index ae7e007..734bae2 100644
--- a/splitter/src/lib.rs
+++ b/splitter/src/lib.rs
@@ -8,9 +8,11 @@ pub mod treepp {
     pub use bitcoin::ScriptBuf as Script;
 }
 
-pub(crate) mod debug;
 pub mod split;
+
+pub(crate) mod debug;
 pub(crate) mod test_scripts;
+pub(crate) mod utils;
 
 #[cfg(test)]
 mod tests {
diff --git a/splitter/src/split/intermediate_state.rs b/splitter/src/split/intermediate_state.rs
index e7412d1..4efebd0 100644
--- a/splitter/src/split/intermediate_state.rs
+++ b/splitter/src/split/intermediate_state.rs
@@ -1,7 +1,7 @@
 //! This module contains the [`IntermediateState`] struct, which is used to store the intermediate
 //! state of the stack and altstack during the execution of a script split into the shards (subprograms).
 
-use crate::treepp::*;
+use crate::{treepp::*, utils::stack_to_script};
 use bitcoin_scriptexec::Stack;
 
 pub struct IntermediateState {
@@ -36,11 +36,11 @@ impl IntermediateState {
             // are used to avoid panic when referencing the first element
             // of the stack or altstack (by using get(0) method)
             if !stack.is_empty() {
-                { stack.get(0) }
+                { stack_to_script(stack) }
             }
 
             if !altstack.is_empty() {
-                { altstack.get(0) }
+                { stack_to_script(altstack) }
 
                 for _ in 0..altstack.len() {
                     OP_TOALTSTACK
diff --git a/splitter/src/split/script.rs b/splitter/src/split/script.rs
index e681520..3465ffc 100644
--- a/splitter/src/split/script.rs
+++ b/splitter/src/split/script.rs
@@ -22,6 +22,9 @@ pub struct SplitResult {
 
 /// Trait that any script that can be split should implement
 pub trait SplitableScript<const INPUT_SIZE: usize, const OUTPUT_SIZE: usize> {
+    const INPUT_SIZE: usize = INPUT_SIZE;
+    const OUTPUT_SIZE: usize = OUTPUT_SIZE;
+
     /// Returns the main logic (f) of the script
     fn script() -> Script;
 
diff --git a/splitter/src/split/tests.rs b/splitter/src/split/tests.rs
index 1f6a992..c1d17b8 100644
--- a/splitter/src/split/tests.rs
+++ b/splitter/src/split/tests.rs
@@ -1,11 +1,19 @@
-use crate::treepp::*;
+use crate::{
+    split::script::{IOPair, SplitableScript},
+    test_scripts::int_mul::U254MulScript,
+    treepp::*,
+    utils::stack_to_script,
+};
 
-use super::core::split_into_shards;
+use super::{
+    core::split_into_shards,
+    intermediate_state::{self, IntermediateState},
+};
 
 /// Tests whether splitting the script into subprograms (shards)
-/// works properly
+/// works properly for the most basic script
 #[test]
-fn test_split() {
+fn test_split_basic() {
     const CHUNK_SIZE: usize = 3;
 
     // Adding a toy script to test the splitting
@@ -53,4 +61,172 @@ fn test_split() {
         !shard_3_result.success,
         "Shard 3 for somer reason succeeded"
     );
+
+    // Now, we are going to concatenate all the shards and verify that the script is also correct
+    let verification_script = script! {
+        for shard in shards {
+            { shard }
+        }
+    };
+    let result = execute_script(verification_script);
+    assert!(result.success, "Verification has failed");
+}
+
+/// Tests whether splitting the script into subprograms (shards)
+/// works properly for the most advanced script (two big integers multipication)
+#[test]
+fn test_split_mul() {
+    const CHUNK_SIZE: usize = 100;
+
+    // Generating a random valid input for the script and the script itself
+    let test_script = U254MulScript::script();
+    let IOPair { input, output } = U254MulScript::generate_valid_io_pair();
+    assert!(
+        U254MulScript::verify(input.clone(), output.clone()),
+        "input/output is not correct"
+    );
+
+    // Splitting the script into shards
+    let shards = split_into_shards(&test_script, CHUNK_SIZE);
+
+    // Now, we are going to concatenate all the shards and verify that the script is also correct
+    let verification_script = script! {
+        { input }
+        for shard in shards {
+            { shard }
+        }
+        { output }
+
+        // Now, we need to verify that the output is correct.
+        for i in (0..U254MulScript::OUTPUT_SIZE).rev() {
+            // { <a_1> <a_2> ... <a_n> <b_1> <b_2> ... <b_n> } <- we need to push element <a_n> to the top of the stack
+            { i+1 } OP_ROLL
+            OP_EQUALVERIFY
+        }
+
+        OP_TRUE
+    };
+
+    let result = execute_script(verification_script);
+    assert!(result.success, "Verification has failed");
+}
+
+#[test]
+fn test_from_input_script_mainstack_only() {
+    // Adding input and verification scripts
+    let input_script = script! {
+        { 13123 } { 1235 }
+    };
+    let main_script = script! {
+        OP_ADD 1 OP_ADD 3 OP_ADD
+    };
+
+    // Creating an intermediate state
+    let IntermediateState { stack, altstack } =
+        IntermediateState::from_input_script(&input_script, &main_script);
+
+    // Asserting that the altstack is empty
+    assert!(altstack.is_empty(), "Altstack is not empty");
+
+    // Now, checking that our stack is simply a number 14362
+    let verify_script = script! {
+        { stack_to_script(&stack) }
+        { 14362 }
+        OP_EQUAL
+    };
+    let result = execute_script(verify_script);
+    assert!(result.success, "Verification failed");
+}
+
+#[test]
+fn test_state_from_input_script_mainstack_and_altstack() {
+    // Adding input and verification scripts
+    let input_script = script! {
+        {13123} {1235}
+    };
+    let main_script = script! {
+        OP_ADD 1 OP_ADD 3 OP_ADD 5 OP_TOALTSTACK
+    };
+
+    // Creating an intermediate state
+    let IntermediateState { stack, altstack } =
+        IntermediateState::from_input_script(&input_script, &main_script);
+
+    // Now, checking that our stack is simply a number 14362
+    let verify_mainstack_script = script! {
+        { stack_to_script(&stack) }
+        {14362}
+        OP_EQUAL
+    };
+    let result = execute_script(verify_mainstack_script);
+    assert!(result.success, "mainstack verification failed");
+
+    // Asserting that the altstack is correct
+    let verify_altstack_script = script! {
+        { stack_to_script(&altstack) }
+        { 5 }
+        OP_EQUAL
+    };
+    let result = execute_script(verify_altstack_script);
+    assert!(result.success, "altstack verification failed");
+}
+
+#[test]
+fn test_state_from_state() {
+    const CHUNK_SIZE: usize = 3;
+
+    // Adding input and verification scripts
+    let input_script = script! {
+        { 10 } { 20 }
+    };
+    let main_script = script! {
+        OP_1 OP_TOALTSTACK OP_1 OP_TOALTSTACK OP_0 OP_TOALTSTACK
+        OP_FROMALTSTACK OP_FROMALTSTACK OP_FROMALTSTACK
+        OP_ADD OP_ADD OP_ADD
+    };
+
+    // Now, splitting the main_script:
+    let shards = split_into_shards(&main_script, CHUNK_SIZE);
+
+    // Creating the first intermediate state
+    let z1 = IntermediateState::from_input_script(&input_script, &shards[0]);
+
+    // Asserting that both the stack and altstack are correct
+    let verify_main_stack_script = script! {
+        { stack_to_script(&z1.stack) }
+        OP_1 OP_EQUALVERIFY
+        { 20 } OP_EQUALVERIFY
+        { 10 } OP_EQUAL
+    };
+
+    let result = execute_script(verify_main_stack_script);
+    assert!(result.success, "Mainstack verification failed");
+
+    let verify_alt_stack_script = script! {
+        { stack_to_script(&z1.altstack) }
+        OP_1 OP_EQUAL
+    };
+    let result = execute_script(verify_alt_stack_script);
+    assert!(result.success, "Altstack verification failed");
+
+    // Now, getting the second state
+    let z2 = IntermediateState::from_intermediate_result(&z1, &shards[1]);
+
+    // Asserting that both the stack and altstack are correct
+    let verify_main_stack_script = script! {
+        { stack_to_script(&z2.stack) }
+        { 20 } OP_EQUALVERIFY
+        { 10 } OP_EQUAL
+    };
+    let result = execute_script(verify_main_stack_script);
+    assert!(result.success, "Mainstack verification failed");
+
+    let verify_alt_stack_script = script! {
+        { stack_to_script(&z2.altstack) }
+        OP_0 OP_EQUALVERIFY
+        OP_1 OP_EQUALVERIFY
+        OP_1 OP_EQUAL
+    };
+    let result = execute_script(verify_alt_stack_script);
+    assert!(result.success, "Altstack verification failed");
 }
diff --git a/splitter/src/utils.rs b/splitter/src/utils.rs
new file mode 100644
index 0000000..24ce002
--- /dev/null
+++ b/splitter/src/utils.rs
@@ -0,0 +1,11 @@
+use bitcoin_scriptexec::Stack;
+
+use crate::treepp::*;
+
+pub(crate) fn stack_to_script(stack: &Stack) -> Script {
+    script! {
+        for element in stack.iter_str() {
+            { element.to_vec() }
+        }
+    }
+}

From 74c48837e1c17c01db9ea3816c5294ef3c86e960 Mon Sep 17 00:00:00 2001
From: ZamDimon <zamdmytro@gmail.com>
Date: Tue, 17 Sep 2024 18:29:23 +0300
Subject: [PATCH 11/17] :adhesive_bandage: :bug: fix from intermediate state
 function

---
 splitter/src/split/intermediate_state.rs |  3 +-
 splitter/src/split/tests.rs              | 66 ++++++++++++++++++++--
 splitter/src/test_scripts/int_mul.rs     | 70 ++++++++++++++++++------
 3 files changed, 116 insertions(+), 23 deletions(-)

diff --git a/splitter/src/split/intermediate_state.rs b/splitter/src/split/intermediate_state.rs
index 4efebd0..034cab6 100644
--- a/splitter/src/split/intermediate_state.rs
+++ b/splitter/src/split/intermediate_state.rs
@@ -42,7 +42,8 @@ impl IntermediateState {
             if !altstack.is_empty() {
                 { stack_to_script(altstack) }
 
-                for _ in 0..altstack.len() {
+                for i in (0..altstack.len()).into_iter().rev() {
+                    { i } OP_ROLL
                     OP_TOALTSTACK
                 }
             }
diff --git a/splitter/src/split/tests.rs b/splitter/src/split/tests.rs
index c1d17b8..2facd58 100644
--- a/splitter/src/split/tests.rs
+++ b/splitter/src/split/tests.rs
@@ -7,7 +7,7 @@ use crate::{
 
 use super::{
     core::split_into_shards,
-    intermediate_state::{self, IntermediateState},
+    intermediate_state::IntermediateState,
 };
 
 /// Tests whether splitting the script into subprograms (shards)
@@ -139,7 +139,7 @@ fn test_from_input_script_mainstack_only() {
 }
 
 #[test]
-fn test_state_from_input_script_mainstack_and_altstack() {
+fn test_state_from_input_script_mainstack_and_altstack_1() {
     // Adding input and verification scripts
     let input_script = script! {
         {13123} {1235}
@@ -171,6 +171,43 @@ fn test_state_from_input_script_mainstack_and_altstack() {
     assert!(result.success, "altstack verification failed");
 }
 
+#[test]
+fn test_state_from_input_script_mainstack_and_altstack_2() {
+    // Adding input and verification scripts
+    let input_script = script! {
+        { 13123 } { 1235 }
+    };
+    let main_script = script! {
+        OP_ADD OP_1 OP_ADD OP_3 OP_ADD 
+        { 5 }  OP_TOALTSTACK 
+        { 100 } OP_TOALTSTACK 
+        { 20050 } OP_TOALTSTACK
+    };
+
+    // Creating an intermediate state
+    let IntermediateState { stack, altstack } =
+        IntermediateState::from_input_script(&input_script, &main_script);
+
+    // Now, checking that our stack is simply a number 14362
+    let verify_mainstack_script = script! {
+        { stack_to_script(&stack) }
+        { 14362 }
+        OP_EQUAL
+    };
+    let result = execute_script(verify_mainstack_script);
+    assert!(result.success, "mainstack verification failed");
+
+    // Asserting that the altstack is correct
+    let verify_altstack_script = script! {
+        { stack_to_script(&altstack) }
+        { 20050 } OP_EQUALVERIFY
+        { 100 } OP_EQUALVERIFY
+        { 5 } OP_EQUAL
+    };
+    let result = execute_script(verify_altstack_script);
+    assert!(result.success, "altstack verification failed");
+}
+
 #[test]
 fn test_state_from_state() {
     const CHUNK_SIZE: usize = 3;
@@ -200,14 +237,14 @@ fn test_state_from_state() {
     };
 
     let result = execute_script(verify_main_stack_script);
-    assert!(result.success, "Mainstack verification failed");
+    assert!(result.success, "z1 mainstack verification failed");
 
     let verify_alt_stack_script = script! {
         { stack_to_script(&z1.altstack) }
         OP_1 OP_EQUAL
     };
     let result = execute_script(verify_alt_stack_script);
-    assert!(result.success, "Altstack verification failed");
+    assert!(result.success, "z1 altstack verification failed");
 
     // Now, getting the second state
     let z2 = IntermediateState::from_intermediate_result(&z1, &shards[1]);
@@ -219,7 +256,7 @@ fn test_state_from_state() {
         { 10 } OP_EQUAL
     };
     let result = execute_script(verify_main_stack_script);
-    assert!(result.success, "Mainstack verification failed");
+    assert!(result.success, "z2 mainstack verification failed");
 
     let verify_alt_stack_script = script! {
         { stack_to_script(&z2.altstack) }
@@ -228,5 +265,22 @@ fn test_state_from_state() {
         OP_1 OP_EQUAL
     };
     let result = execute_script(verify_alt_stack_script);
-    assert!(result.success, "Altstack verification failed");
+    assert!(result.success, "z2 altstack verification failed");
+
+    // Now, getting the third state
+    let z3 = IntermediateState::from_intermediate_result(&z2, &shards[2]);
+
+    // Asserting that both the stack and altstack are correct
+    let verify_main_stack_script = script! {
+        { stack_to_script(&z3.stack) }
+        OP_1 OP_EQUALVERIFY
+        OP_1 OP_EQUALVERIFY
+        OP_0 OP_EQUALVERIFY
+        { 20 } OP_EQUALVERIFY
+        { 10 } OP_EQUAL
+    };
+    let result = execute_script(verify_main_stack_script);
+    assert!(result.success, "z3 mainstack verification failed");
+
+    assert!(z3.altstack.is_empty(), "z3 altstack should be empty at this point");
 }
diff --git a/splitter/src/test_scripts/int_mul.rs b/splitter/src/test_scripts/int_mul.rs
index c27465c..57948c4 100644
--- a/splitter/src/test_scripts/int_mul.rs
+++ b/splitter/src/test_scripts/int_mul.rs
@@ -48,6 +48,10 @@ impl SplitableScript<{ INPUT_SIZE }, { OUTPUT_SIZE }> for U254MulScript {
 
 #[cfg(test)]
 mod tests {
+    use bitcoin_window_mul::traits::comparable::Comparable;
+
+    use crate::utils::stack_to_script;
+
     use super::*;
 
     #[test]
@@ -56,25 +60,59 @@ mod tests {
     }
 
     #[test]
-    fn test_split() {
+    fn test_naive_split_correctness() {
+        // Generating a random valid input for the script and the script itself
+        let IOPair { input, output } = U254MulScript::generate_valid_io_pair();
+        assert!(
+            U254MulScript::verify(input.clone(), output.clone()),
+            "input/output is not correct"
+        );
+
+        // Splitting the script into shards
+        let split_result = U254MulScript::split(input.clone());
+
+        // Now, we are going to concatenate all the shards and verify that the script is also correct
+        let verification_script = script! {
+            { input }
+            for shard in split_result.shards {
+                { shard }
+            }
+            { output }
+
+            // Now, we need to verify that the output is correct.
+            for i in (0..U254MulScript::OUTPUT_SIZE).rev() {
+                // { <a_1> <a_2> ... <a_n> <b_1> <b_2> ... <b_n> } <- we need to push element <a_n> to the top of the stack
+                { i+1 } OP_ROLL
+                OP_EQUALVERIFY
+            }
+
+            OP_TRUE
+        };
+
+        let result = execute_script(verification_script);
+        assert!(result.success, "Verification has failed");
+    }
+
+    #[test]
+    fn test_naive_split() {
         // First, we generate the pair of input and output scripts
-        let IOPair {
-            input,
-            output: _output,
-        } = U254MulScript::generate_valid_io_pair();
+        let IOPair { input, output } = U254MulScript::generate_valid_io_pair();
 
         let split_result = U254MulScript::split(input);
-        for shard in split_result.shards {
-            println!("Shard is of length {}", shard.len());
-        }
+        
+        // Now, let us check the last shard
+        let last_state = split_result.intermediate_states.last().unwrap();
+        
+        println!("Expect: {:?}", output.as_script().to_asm_string());
+        println!("Actual: {:?}", stack_to_script(&last_state.stack).to_asm_string());
 
-        println!("Intermediate results:");
-        for intermediate_result in split_result.intermediate_states {
-            println!(
-                "Intermediate results: {};{}",
-                intermediate_result.stack.len(),
-                intermediate_result.altstack.len()
-            );
-        }
+        let verification_script = script! {
+            { stack_to_script(&last_state.stack) }
+            { output }
+            { U508::OP_EQUAL(0, 1) }
+        };
+
+        let result = execute_script(verification_script);
+        assert!(result.success, "Verification has failed");
     }
 }

From f33d9d830d522cdabbc04570ff1a216b60b4a03b Mon Sep 17 00:00:00 2001
From: ZamDimon <zamdmytro@gmail.com>
Date: Tue, 17 Sep 2024 18:35:28 +0300
Subject: [PATCH 12/17] :green_heart: :art: polishes to make CI happy

---
 splitter/src/split/intermediate_state.rs |  2 +-
 splitter/src/split/script.rs             | 25 ++++++++++++++++++++++++
 splitter/src/split/tests.rs              | 16 +++++++--------
 splitter/src/test_scripts/int_mul.rs     | 16 ++++++++-------
 4 files changed, 43 insertions(+), 16 deletions(-)

diff --git a/splitter/src/split/intermediate_state.rs b/splitter/src/split/intermediate_state.rs
index 034cab6..14393e8 100644
--- a/splitter/src/split/intermediate_state.rs
+++ b/splitter/src/split/intermediate_state.rs
@@ -42,7 +42,7 @@ impl IntermediateState {
             if !altstack.is_empty() {
                 { stack_to_script(altstack) }
 
-                for i in (0..altstack.len()).into_iter().rev() {
+                for i in (0..altstack.len()).rev() {
                     { i } OP_ROLL
                     OP_TOALTSTACK
                 }
diff --git a/splitter/src/split/script.rs b/splitter/src/split/script.rs
index 3465ffc..88dd8c1 100644
--- a/splitter/src/split/script.rs
+++ b/splitter/src/split/script.rs
@@ -20,6 +20,31 @@ pub struct SplitResult {
     pub intermediate_states: Vec<IntermediateState>,
 }
 
+impl SplitResult {
+    /// Creates a new instance of the SplitResult
+    pub fn new(shards: Vec<Script>, intermediate_states: Vec<IntermediateState>) -> Self {
+        Self {
+            shards,
+            intermediate_states,
+        }
+    }
+
+    /// Returns the last intermediate state, ignoring the possibility of the empty vector
+    pub fn must_last_state(&self) -> &IntermediateState {
+        self.intermediate_states
+            .last()
+            .expect("Intermediate states should not be empty")
+    }
+
+    /// Returns the total size of the states (stack + altstack)
+    pub fn total_states_size(&self) -> usize {
+        self.intermediate_states
+            .iter()
+            .map(|state| state.stack.len() + state.altstack.len())
+            .sum()
+    }
+}
+
 /// Trait that any script that can be split should implement
 pub trait SplitableScript<const INPUT_SIZE: usize, const OUTPUT_SIZE: usize> {
     const INPUT_SIZE: usize = INPUT_SIZE;
diff --git a/splitter/src/split/tests.rs b/splitter/src/split/tests.rs
index 2facd58..b18d93b 100644
--- a/splitter/src/split/tests.rs
+++ b/splitter/src/split/tests.rs
@@ -5,10 +5,7 @@ use crate::{
     utils::stack_to_script,
 };
 
-use super::{
-    core::split_into_shards,
-    intermediate_state::IntermediateState,
-};
+use super::{core::split_into_shards, intermediate_state::IntermediateState};
 
 /// Tests whether splitting the script into subprograms (shards)
 /// works properly for the most basic script
@@ -178,9 +175,9 @@ fn test_state_from_input_script_mainstack_and_altstack_2() {
         { 13123 } { 1235 }
     };
     let main_script = script! {
-        OP_ADD OP_1 OP_ADD OP_3 OP_ADD 
-        { 5 }  OP_TOALTSTACK 
-        { 100 } OP_TOALTSTACK 
+        OP_ADD OP_1 OP_ADD OP_3 OP_ADD
+        { 5 }  OP_TOALTSTACK
+        { 100 } OP_TOALTSTACK
         { 20050 } OP_TOALTSTACK
     };
 
@@ -282,5 +279,8 @@ fn test_state_from_state() {
     let result = execute_script(verify_main_stack_script);
     assert!(result.success, "z3 mainstack verification failed");
 
-    assert!(z3.altstack.is_empty(), "z3 altstack should be empty at this point");
+    assert!(
+        z3.altstack.is_empty(),
+        "z3 altstack should be empty at this point"
+    );
 }
diff --git a/splitter/src/test_scripts/int_mul.rs b/splitter/src/test_scripts/int_mul.rs
index 57948c4..f6970cd 100644
--- a/splitter/src/test_scripts/int_mul.rs
+++ b/splitter/src/test_scripts/int_mul.rs
@@ -98,14 +98,16 @@ mod tests {
         // First, we generate the pair of input and output scripts
         let IOPair { input, output } = U254MulScript::generate_valid_io_pair();
 
+        // Splitting the script into shards
         let split_result = U254MulScript::split(input);
-        
-        // Now, let us check the last shard
-        let last_state = split_result.intermediate_states.last().unwrap();
-        
-        println!("Expect: {:?}", output.as_script().to_asm_string());
-        println!("Actual: {:?}", stack_to_script(&last_state.stack).to_asm_string());
 
+        // Checking the last state (which must be equal to the result of the multiplication)
+        let last_state = split_result.must_last_state();
+
+        // Altstack must be empty
+        assert!(last_state.altstack.is_empty(), "altstack is not empty!");
+
+        // The element of the mainstack must be equal to the actual output
         let verification_script = script! {
             { stack_to_script(&last_state.stack) }
             { output }
@@ -113,6 +115,6 @@ mod tests {
         };
 
         let result = execute_script(verification_script);
-        assert!(result.success, "Verification has failed");
+        assert!(result.success, "verification has failed");
     }
 }

From 499c4bffbc77032d6ee08e6bba382a7d9d7850ab Mon Sep 17 00:00:00 2001
From: ZamDimon <zamdmytro@gmail.com>
Date: Wed, 18 Sep 2024 18:29:09 +0300
Subject: [PATCH 13/17] :art: tiny polishes

---
 splitter/src/debug.rs                |  2 +
 splitter/src/split/tests.rs          |  6 +--
 splitter/src/test_scripts/int_add.rs | 67 ++++++++++++++++++++++++++++
 splitter/src/test_scripts/int_mul.rs | 10 +++--
 4 files changed, 78 insertions(+), 7 deletions(-)

diff --git a/splitter/src/debug.rs b/splitter/src/debug.rs
index b48113a..62ac034 100644
--- a/splitter/src/debug.rs
+++ b/splitter/src/debug.rs
@@ -20,6 +20,7 @@ impl fmt::Display for ExecuteInfo {
         } else {
             writeln!(f, "Script execution failed!")?;
         }
+
         if let Some(ref error) = self.error {
             writeln!(f, "Error: {:?}", error)?;
         }
@@ -35,6 +36,7 @@ pub fn execute_script(script: ScriptBuf) -> ExecuteInfo {
     let mut exec = Exec::new(
         ExecCtx::Tapscript,
         Options {
+            // TODO: Figure our how to optimize stack_to_script function to avoid disabling require_minimal
             require_minimal: false,
             ..Default::default()
         },
diff --git a/splitter/src/split/tests.rs b/splitter/src/split/tests.rs
index b18d93b..ba199d3 100644
--- a/splitter/src/split/tests.rs
+++ b/splitter/src/split/tests.rs
@@ -29,9 +29,9 @@ fn test_split_basic() {
 
     // Asserting that we have three shards and each shard has at most three elements in the stack
     assert_eq!(shards.len(), 3, "Shards number is incorrect");
-    for i in 0..3 {
-        println!("Shard {}: {}", i, shards[i].to_asm_string());
-        println!("Shard {} size: {}", i, shards[i].len());
+    for (i, shard) in shards.clone().into_iter().enumerate() {
+        println!("Shard {}: {}", i, shard.to_asm_string());
+        println!("Shard {} size: {}", i, shard.len());
     }
 
     // Asserting that the shards are correct
diff --git a/splitter/src/test_scripts/int_add.rs b/splitter/src/test_scripts/int_add.rs
index a816f98..3597447 100644
--- a/splitter/src/test_scripts/int_add.rs
+++ b/splitter/src/test_scripts/int_add.rs
@@ -53,10 +53,77 @@ impl SplitableScript<{ INPUT_SIZE }, { OUTPUT_SIZE }> for U254AddScript {
 
 #[cfg(test)]
 mod tests {
+    use bitcoin_window_mul::traits::comparable::Comparable;
+
+    use crate::utils::stack_to_script;
+
     use super::*;
 
     #[test]
     fn test_verify() {
         assert!(U254AddScript::verify_random());
     }
+
+    #[test]
+    fn test_naive_split_correctness() {
+        // Generating a random valid input for the script and the script itself
+        let IOPair { input, output } = U254AddScript::generate_valid_io_pair();
+        assert!(
+            U254AddScript::verify(input.clone(), output.clone()),
+            "input/output is not correct"
+        );
+
+        // Splitting the script into shards
+        let split_result = U254AddScript::split(input.clone());
+
+        // Now, we are going to concatenate all the shards and verify that the script is also correct
+        let verification_script = script! {
+            { input }
+            for shard in split_result.shards {
+                { shard }
+            }
+            { output }
+
+            // Now, we need to verify that the output is correct.
+            for i in (0..U254AddScript::OUTPUT_SIZE).rev() {
+                // { <a_1> <a_2> ... <a_n> <b_1> <b_2> ... <b_n> } <- we need to push element <a_n> to the top of the stack
+                { i+1 } OP_ROLL
+                OP_EQUALVERIFY
+            }
+
+            OP_TRUE
+        };
+
+        let result = execute_script(verification_script);
+        assert!(result.success, "Verification has failed");
+    }
+
+    #[test]
+    fn test_naive_split() {
+        // First, we generate the pair of input and output scripts
+        let IOPair { input, output } = U254AddScript::generate_valid_io_pair();
+
+        // Splitting the script into shards
+        let split_result = U254AddScript::split(input);
+
+        // Checking the last state (which must be equal to the result of the multiplication)
+        let last_state = split_result.must_last_state();
+
+        // Altstack must be empty
+        assert!(last_state.altstack.is_empty(), "altstack is not empty!");
+
+        // The element of the mainstack must be equal to the actual output
+        let verification_script = script! {
+            { stack_to_script(&last_state.stack) }
+            { output }
+            { U254::OP_EQUAL(0, 1) }
+        };
+
+        let result = execute_script(verification_script);
+        assert!(result.success, "verification has failed");
+
+        // Now, we debug the total size of the states
+        let total_size = split_result.total_states_size();
+        println!("Total size of the states: {} bytes", total_size);
+    }
 }
diff --git a/splitter/src/test_scripts/int_mul.rs b/splitter/src/test_scripts/int_mul.rs
index f6970cd..1876880 100644
--- a/splitter/src/test_scripts/int_mul.rs
+++ b/splitter/src/test_scripts/int_mul.rs
@@ -48,11 +48,9 @@ impl SplitableScript<{ INPUT_SIZE }, { OUTPUT_SIZE }> for U254MulScript {
 
 #[cfg(test)]
 mod tests {
-    use bitcoin_window_mul::traits::comparable::Comparable;
-
-    use crate::utils::stack_to_script;
-
     use super::*;
+    use crate::utils::stack_to_script;
+    use bitcoin_window_mul::traits::comparable::Comparable;
 
     #[test]
     fn test_verify() {
@@ -116,5 +114,9 @@ mod tests {
 
         let result = execute_script(verification_script);
         assert!(result.success, "verification has failed");
+
+        // Now, we debug the total size of the states
+        let total_size = split_result.total_states_size();
+        println!("Total size of the states: {} bytes", total_size);
     }
 }

From 66b4c625cfed12323cebfe4b0ccdb0617f112a6f Mon Sep 17 00:00:00 2001
From: ZamDimon <zamdmytro@gmail.com>
Date: Thu, 19 Sep 2024 20:20:52 +0300
Subject: [PATCH 14/17] :construction: :tada: import sha256 for demonstration
 purposes

---
 splitter/Cargo.toml                     |    6 +-
 splitter/src/bitvm/hash/mod.rs          |    2 +
 splitter/src/bitvm/hash/sha256.rs       | 1166 +++++++++++++++++++++++
 splitter/src/bitvm/hash/utils.rs        |   19 +
 splitter/src/bitvm/mod.rs               |    5 +
 splitter/src/bitvm/u32/mod.rs           |    6 +
 splitter/src/bitvm/u32/u32_add.rs       |  129 +++
 splitter/src/bitvm/u32/u32_and.rs       |  132 +++
 splitter/src/bitvm/u32/u32_rrot.rs      |  258 +++++
 splitter/src/bitvm/u32/u32_std.rs       |  214 +++++
 splitter/src/bitvm/u32/u32_xor.rs       |  373 ++++++++
 splitter/src/bitvm/u32/u32_zip.rs       |   59 ++
 splitter/src/debug.rs                   |   11 +
 splitter/src/lib.rs                     |    2 +
 splitter/src/pseudo.rs                  |  169 ++++
 splitter/src/test_scripts/mod.rs        |    1 +
 splitter/src/test_scripts/sha256/mod.rs |   95 ++
 17 files changed, 2645 insertions(+), 2 deletions(-)
 create mode 100644 splitter/src/bitvm/hash/mod.rs
 create mode 100644 splitter/src/bitvm/hash/sha256.rs
 create mode 100644 splitter/src/bitvm/hash/utils.rs
 create mode 100644 splitter/src/bitvm/mod.rs
 create mode 100644 splitter/src/bitvm/u32/mod.rs
 create mode 100644 splitter/src/bitvm/u32/u32_add.rs
 create mode 100644 splitter/src/bitvm/u32/u32_and.rs
 create mode 100644 splitter/src/bitvm/u32/u32_rrot.rs
 create mode 100644 splitter/src/bitvm/u32/u32_std.rs
 create mode 100644 splitter/src/bitvm/u32/u32_xor.rs
 create mode 100644 splitter/src/bitvm/u32/u32_zip.rs
 create mode 100644 splitter/src/pseudo.rs
 create mode 100644 splitter/src/test_scripts/sha256/mod.rs

diff --git a/splitter/Cargo.toml b/splitter/Cargo.toml
index 383809d..a8b9eec 100644
--- a/splitter/Cargo.toml
+++ b/splitter/Cargo.toml
@@ -9,8 +9,9 @@ bitcoin              = { git = "https://github.com/rust-bitcoin/rust-bitcoin", b
 bitcoin-script       = { git = "https://github.com/BitVM/rust-bitcoin-script" }
 bitcoin-scriptexec   = { git = "https://github.com/BitVM/rust-bitcoin-scriptexec/"}
 bitcoin-script-stack = { git = "https://github.com/FairgateLabs/rust-bitcoin-script-stack"}
-# Some test script to test the splitter
-bitcoin-window-mul   = { git = "https://github.com/distributed-lab/bitcoin-window-mul.git" }
+
+# BitVM scripts
+bitcoin-window-mul = { git = "https://github.com/distributed-lab/bitcoin-window-mul.git" }
 
 # General-purpose libraries
 strum          = "0.26"
@@ -21,6 +22,7 @@ tokio          = { version = "1.37.0", features = ["full"] }
 
 # Crypto libraries
 hex        = "0.4.3"
+sha2       = "0.10.8"
 num-bigint = { version = "0.4.4", features = ["rand"] }
 num-traits = "0.2.18"
 
diff --git a/splitter/src/bitvm/hash/mod.rs b/splitter/src/bitvm/hash/mod.rs
new file mode 100644
index 0000000..7c33308
--- /dev/null
+++ b/splitter/src/bitvm/hash/mod.rs
@@ -0,0 +1,2 @@
+pub mod sha256;
+pub mod utils;
\ No newline at end of file
diff --git a/splitter/src/bitvm/hash/sha256.rs b/splitter/src/bitvm/hash/sha256.rs
new file mode 100644
index 0000000..3a27dc0
--- /dev/null
+++ b/splitter/src/bitvm/hash/sha256.rs
@@ -0,0 +1,1166 @@
+#![allow(non_snake_case)]
+
+use crate::pseudo::push_to_stack;
+use crate::treepp::*;
+use crate::bitvm::u32::u32_add::u32_add_drop;
+use crate::bitvm::u32::u32_std::{u32_dup, u32_roll};
+use crate::bitvm::u32::{
+    u32_and::u32_and,
+    u32_rrot::u32_rrot,
+    u32_std::{u32_drop, u32_fromaltstack, u32_pick, u32_push, u32_toaltstack},
+    u32_xor::{u32_xor, u8_drop_xor_table, u8_push_xor_table},
+};
+
+const K: [u32; 64] = [
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+];
+
+const INITSTATE: [u32; 8] = [
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+];
+
+/// sha256 take indefinite length input on the top of stack and return 256 bit (64 byte)
+pub fn sha256(num_bytes: usize) -> Script {
+    if num_bytes == 32 {
+        return sha256_32bytes();
+    }
+    if num_bytes == 80 {
+        return sha256_80bytes();
+    }
+    let mut chunks_size: usize = num_bytes / 64 + 1;
+    if (num_bytes % 64) > 55 {
+        chunks_size += 1;
+    }
+
+    script! {
+        {push_reverse_bytes_to_alt(num_bytes)}
+
+        // top of stack: [ [n bytes input] ]
+        {u8_push_xor_table()}
+        {sha256_k()}
+        // top of stack: [ [64 byte chunks]... ]
+        {padding_add_roll(num_bytes)}
+        {sha256_init()}
+        // top of stack: [ [64 byte chunks]..., state[0-7]]
+        for i in 0..chunks_size {
+            {sha256_transform(8 + ((chunks_size as u32) - i as u32) *16 + 64 + 1, 8 + ((chunks_size as u32) - i as u32)  *16)}
+        }
+
+        {sha256_final()}
+        for _ in 0..8 {
+            {u32_toaltstack()}
+        }
+        for _ in 0..64 {
+            {u32_drop()}
+        }
+        {u8_drop_xor_table()}
+
+        for _ in 0..8 {
+            {u32_fromaltstack()}
+        }
+    }
+}
+
+pub fn sha256_32bytes() -> Script {
+    script! {
+        {push_reverse_bytes_to_alt(32)}
+
+        // top of stack: [ [n bytes input] ]
+        {u8_push_xor_table()}
+        {sha256_k()}
+        // top of stack: [ [64 byte chunks]... ]
+        {padding_add_roll(32)}
+        {sha256_init()}
+        // top of stack: [ [64 byte chunks]..., state[0-7]]
+        {sha256_transform_32bytes(8 + 16 + 64 + 1, 8 + 16)}
+
+        {sha256_final()}
+        for _ in 0..8 {
+            {u32_toaltstack()}
+        }
+        for _ in 0..64 {
+            {u32_drop()}
+        }
+        {u8_drop_xor_table()}
+
+        for _ in 0..8 {
+            {u32_fromaltstack()}
+        }
+    }
+}
+
+pub fn sha256_80bytes() -> Script {
+    script! {
+        {push_reverse_bytes_to_alt(80)}
+
+        // top of stack: [ [n bytes input] ]
+        {u8_push_xor_table()}
+        {sha256_k()}
+        // top of stack: [ [64 byte chunks]... ]
+        {padding_add_roll(80)}
+        {sha256_init()}
+        // top of stack: [ [64 byte chunks]..., state[0-7]]
+        // chunk 1
+        {sha256_transform(8 + 2 * 16 + 64 + 1, 8 + 2 * 16)}
+        // chunk 2
+        {sha256_transform_80bytes_chunk2(8 + 16 + 64 + 1, 8 + 16)}
+
+        {sha256_final()}
+        for _ in 0..8 {
+            {u32_toaltstack()}
+        }
+        for _ in 0..64 {
+            {u32_drop()}
+        }
+        {u8_drop_xor_table()}
+
+        for _ in 0..8 {
+            {u32_fromaltstack()}
+        }
+    }
+}
+
+/// reorder bytes for u32
+pub fn padding_add_roll(num_bytes: usize) -> Script {
+    assert!(num_bytes < 512);
+    let padding_num;
+    if (num_bytes % 64) < 56 {
+        padding_num = 55 - (num_bytes % 64);
+    } else {
+        padding_num = 64 + 55 - (num_bytes % 64);
+    }
+
+    let u32_num = (num_bytes + padding_num + 9) / 4;
+    script! {
+        for _ in 0..num_bytes {
+            OP_FROMALTSTACK
+        }
+        {0x80}
+        {push_to_stack(0,padding_num)}
+        {u32_push(0)}
+        {u32_push((num_bytes as u32) * 8)}
+
+        for i in 1..u32_num {
+            {u32_roll(i as u32)}
+        }
+    }
+}
+
+/// push all init state into stack
+pub fn sha256_init() -> Vec<Script> {
+    let mut state: [u32; 8] = INITSTATE;
+    state.reverse();
+    state.iter().map(|x: &u32| u32_push(*x)).collect::<Vec<_>>()
+}
+
+/// Change byte order, because SHA uses big endian.
+pub fn sha256_final() -> Script {
+    script! {
+        for _ in 0..8 {
+            OP_SWAP
+            OP_2SWAP
+            OP_SWAP
+            {u32_toaltstack()}
+        }
+        for _ in 0..8 {
+            {u32_fromaltstack()}
+        }
+    }
+}
+
+/// push other necessary state into stack
+pub fn sha256_k() -> Vec<Script> {
+    let mut state: [u32; 64] = K;
+    state.reverse();
+    state.iter().map(|x: &u32| u32_push(*x)).collect::<Vec<_>>()
+}
+
+/// sha256 transform
+/// intput: [m[15], m[14], ..., m[0], state[7], state[6], ..., state[0]]
+/// output: [state[7], state[6], ..., state[0]]
+pub fn sha256_transform(xor_depth: u32, k_depth: u32) -> Script {
+    script! {
+        // push old state to alt stack
+        for _ in 0..8 {
+            {u32_toaltstack()}
+        }
+
+        // reverse for 16 u32 data
+        for i in 1..16 {
+            {u32_roll(i)}
+        }
+
+        // reorg data
+        for i in 16..64 {
+            {u32_pick(1)}
+            {sig1(xor_depth - 6 + i-16 - 1)}
+
+            {u32_pick(7)}
+            {u32_add_drop(0, 1)}
+
+            {u32_pick(15)}
+            {sig0(xor_depth - 6 + i-16)}
+            {u32_add_drop(0, 1)}
+
+            {u32_pick(16)}
+            {u32_add_drop(0, 1)}
+        }
+
+        // get a copy of states from altstack
+        for _ in 0..8 {
+            {u32_fromaltstack()}
+        }
+
+        for _ in 0..8 {
+            {u32_pick(7)}
+        }
+
+        for _ in 0..8 {
+            {u32_toaltstack()}
+        }
+
+        // already increase 48 elements in the stack
+        // now loop for transform [h, g, f, e, d, c, b, a]
+        for i in 0..64 {
+            // t1 for reuse
+            {u32_toaltstack()}
+            {u32_toaltstack()}
+            {u32_toaltstack()}
+            {u32_toaltstack()}
+
+            // [h, g, f, e]
+            {u32_roll(3)} // [g, f, e, h]
+            {u32_pick(1)} // [g, f, e, h, e]
+            {ep1(xor_depth+45)}
+            {u32_add_drop(0, 1)} // [g, f, e, tmp_t1]
+            {ch(1, 2, 3, xor_depth+44)}
+            {u32_add_drop(0, 1)}
+
+            {u32_pick(k_depth+44+i)} // pick k
+            {u32_add_drop(0, 1)}
+
+            {u32_pick(4+63-i)} // pick m
+            {u32_add_drop(0, 1)}
+
+            // [g, f, e, t1]
+
+            {u32_dup()}
+            {u32_fromaltstack()} // [g, f, e, t1, t1, d]
+            {u32_add_drop(0, 1)} // [g, f, e, t1, t1 + d]
+
+            {u32_fromaltstack()}
+            {u32_fromaltstack()}
+            {u32_fromaltstack()} // [g, f, e, t1, t1+d, c, b, a]
+            {u32_roll(4)} // [g, f, e, t1+d, c, b, a, t1]
+
+            {u32_pick(1)}
+            {ep0(xor_depth+49)}
+            {u32_add_drop(0, 1)}
+
+            {maj(1, 2, 3, xor_depth+48)}
+            {u32_add_drop(0, 1)}
+            // [g, f, e, t1+d, c, b, a, t1+t2]
+        }
+
+        for _ in 0..8 {
+            {u32_fromaltstack()} // get old state
+        }
+
+        // add new state and old state
+        for i in 0..8 {
+            {u32_roll(8-i)}
+            {u32_add_drop(0, 1)}
+            {u32_toaltstack()}
+        }
+
+        for _ in 0..64 {
+            {u32_drop()} // drop m table
+        }
+
+        for _ in 0..8 {
+            {u32_fromaltstack()}
+        }
+    }
+}
+
+pub fn sha256_transform_32bytes(xor_depth: u32, k_depth: u32) -> Script {
+    script! {
+        // push old state to alt stack
+        for _ in 0..8 {
+            {u32_toaltstack()}
+        }
+
+        // reverse for 16 u32 data
+        for i in 1..16 {
+            {u32_roll(i)}
+        }
+
+        // reorg data
+
+        // i = 16, m_16 = m_0 + sig0(m_1)
+        {u32_pick(14)}
+        {sig0(xor_depth - 7)}
+
+        {u32_pick(16)}
+        {u32_add_drop(0, 1)}
+
+        // i = 17, m_17 = m_1 + sig0(m_2) + sig1(256)
+        {u32_push(0x00a00000)} // sig1(256)
+
+        {u32_pick(15)}
+        {sig0(xor_depth - 5)}
+        {u32_add_drop(0, 1)}
+
+        {u32_pick(16)}
+        {u32_add_drop(0, 1)}
+
+        // i = 18, m_18 = m_2 + sig0(m_3) + sig1(m_16)
+        {u32_pick(1)}
+        {sig1(xor_depth - 5)}
+
+        {u32_pick(15)}
+        {sig0(xor_depth - 4)}
+        {u32_add_drop(0, 1)}
+
+        {u32_pick(16)}
+        {u32_add_drop(0, 1)}
+
+        // i = 19, m_19 = m_3 + sig0(m_4) + sig1(m_17)
+        {u32_pick(1)}
+        {sig1(xor_depth - 4)}
+
+        {u32_pick(15)}
+        {sig0(xor_depth - 3)}
+        {u32_add_drop(0, 1)}
+
+        {u32_pick(16)}
+        {u32_add_drop(0, 1)}
+
+        // i = 20, m_20 = m_4 + sig0(m_5) + sig1(m_18)
+        {u32_pick(1)}
+        {sig1(xor_depth - 3)}
+
+        {u32_pick(15)}
+        {sig0(xor_depth - 2)}
+        {u32_add_drop(0, 1)}
+
+        {u32_pick(16)}
+        {u32_add_drop(0, 1)}
+
+        // i = 21, m_21 = m_5 + sig0(m_6) + sig1(m_19)
+        {u32_pick(1)}
+        {sig1(xor_depth - 2)}
+
+        {u32_pick(15)}
+        {sig0(xor_depth - 1)}
+        {u32_add_drop(0, 1)}
+
+        {u32_pick(16)}
+        {u32_add_drop(0, 1)}
+
+        // i = 22, m_22 = m_6 + sig0(m_7) + 256 + sig1(m_20)
+        {u32_pick(1)}
+        {sig1(xor_depth - 1)}
+
+        {u32_push(256)}
+        {u32_add_drop(0, 1)}
+
+        {u32_pick(15)}
+        {sig0(xor_depth)}
+        {u32_add_drop(0, 1)}
+
+        {u32_pick(16)}
+        {u32_add_drop(0, 1)}
+
+        // i = 23, m_23 = m_7 + sig0(0b10...0) + m_16 + sig1(m_21)
+        {u32_pick(1)}
+        {sig1(xor_depth)}
+
+        {u32_pick(7)}
+        {u32_add_drop(0, 1)}
+
+        {u32_push(0x11002000)} // sig0(0b10...0)
+        {u32_add_drop(0, 1)}
+
+        {u32_pick(16)}
+        {u32_add_drop(0, 1)}
+
+        // i = 24, m_24 = 0b10...0 + m_17 + sig1(m_22)
+        {u32_pick(1)}
+        {sig1(xor_depth + 1)}
+
+        {u32_pick(7)}
+        {u32_add_drop(0, 1)}
+
+        {u32_push(0x80000000)}
+        {u32_add_drop(0, 1)}
+
+        // i = 25..30, m_i = m_{i-7} + sig1(m_{i-2})
+        for i in 25..30 {
+            {u32_pick(1)}
+            {sig1(xor_depth - 6 + i - 16 - 1)}
+
+            {u32_pick(7)}
+            {u32_add_drop(0, 1)}
+        }
+
+        // i = 30, m_30 = sig0(256) + m_23 + sig1(m_28)
+        {u32_pick(1)}
+        {sig1(xor_depth + 7)}
+
+        {u32_pick(7)}
+        {u32_add_drop(0, 1)}
+
+        {u32_push(0x00400022)}  // sig0(256)
+        {u32_add_drop(0, 1)}
+
+        // i = 31, m_31 = 256 + sig0(m_16) + m_24 + sig1(m_29)
+        {u32_pick(1)}
+        {sig1(xor_depth + 8)}
+
+        {u32_pick(7)}
+        {u32_add_drop(0, 1)}
+
+        {u32_pick(15)}
+        {sig0(xor_depth + 9)}
+        {u32_add_drop(0, 1)}
+
+        {u32_push(256)}
+        {u32_add_drop(0, 1)}
+
+        for i in 32..64 {
+            {u32_pick(1)}
+            {sig1(xor_depth - 6 + i - 16 - 1)}
+
+            {u32_pick(7)}
+            {u32_add_drop(0, 1)}
+
+            {u32_pick(15)}
+            {sig0(xor_depth - 6 + i - 16)}
+            {u32_add_drop(0, 1)}
+
+            {u32_pick(16)}
+            {u32_add_drop(0, 1)}
+        }
+
+        // get a copy of states from altstack
+        for _ in 0..8 {
+            {u32_fromaltstack()}
+        }
+
+        for _ in 0..8 {
+            {u32_pick(7)}
+        }
+
+        for _ in 0..8 {
+            {u32_toaltstack()}
+        }
+
+        // already increase 48 elements in the stack
+        // now loop for transform [h, g, f, e, d, c, b, a]
+        for i in 0..64 {
+            // t1 for reuse
+            {u32_toaltstack()}
+            {u32_toaltstack()}
+            {u32_toaltstack()}
+            {u32_toaltstack()}
+
+            // [h, g, f, e]
+            {u32_roll(3)} // [g, f, e, h]
+            {u32_pick(1)} // [g, f, e, h, e]
+            {ep1(xor_depth+45)}
+            {u32_add_drop(0, 1)} // [g, f, e, tmp_t1]
+            {ch(1, 2, 3, xor_depth+44)}
+            {u32_add_drop(0, 1)}
+
+            {u32_pick(k_depth+44+i)} // pick k
+            {u32_add_drop(0, 1)}
+
+            {u32_pick(4+63-i)} // pick m
+            {u32_add_drop(0, 1)}
+
+            // [g, f, e, t1]
+
+            {u32_dup()}
+            {u32_fromaltstack()} // [g, f, e, t1, t1, d]
+            {u32_add_drop(0, 1)} // [g, f, e, t1, t1 + d]
+
+            {u32_fromaltstack()}
+            {u32_fromaltstack()}
+            {u32_fromaltstack()} // [g, f, e, t1, t1+d, c, b, a]
+            {u32_roll(4)} // [g, f, e, t1+d, c, b, a, t1]
+
+            {u32_pick(1)}
+            {ep0(xor_depth+49)}
+            {u32_add_drop(0, 1)}
+
+            {maj(1, 2, 3, xor_depth+48)}
+            {u32_add_drop(0, 1)}
+            // [g, f, e, t1+d, c, b, a, t1+t2]
+        }
+
+        for _ in 0..8 {
+            {u32_fromaltstack()} // get old state
+        }
+
+        // add new state and old state
+        for i in 0..8 {
+            {u32_roll(8-i)}
+            {u32_add_drop(0, 1)}
+            {u32_toaltstack()}
+        }
+
+        for _ in 0..64 {
+            {u32_drop()} // drop m table
+        }
+
+        for _ in 0..8 {
+            {u32_fromaltstack()}
+        }
+    }
+}
+
+pub fn sha256_transform_80bytes_chunk2(xor_depth: u32, k_depth: u32) -> Script {
+    script! {
+        // push old state to alt stack
+        for _ in 0..8 {
+            {u32_toaltstack()}
+        }
+
+        // reverse for 16 u32 data
+        for i in 1..16 {
+            {u32_roll(i)}
+        }
+
+        // reorg data
+
+        // i = 16, m_16 = m_0 + sig0(m_1)
+        {u32_pick(14)}
+        {sig0(xor_depth - 7)}
+
+        {u32_pick(16)}
+        {u32_add_drop(0, 1)}
+
+        // i = 17, m_17 = m_1 + sig0(m_2) + sig1(640)
+        {u32_push(0x01100000)} // sig1(640)
+
+        {u32_pick(15)}
+        {sig0(xor_depth - 5)}
+        {u32_add_drop(0, 1)}
+
+        {u32_pick(16)}
+        {u32_add_drop(0, 1)}
+
+        // i = 18, m_18 = m_2 + sig0(m_3) + sig1(m_16)
+        {u32_pick(1)}
+        {sig1(xor_depth - 5)}
+
+        {u32_pick(15)}
+        {sig0(xor_depth - 4)}
+        {u32_add_drop(0, 1)}
+
+        {u32_pick(16)}
+        {u32_add_drop(0, 1)}
+
+        // i = 19, m_19 = m_3 + sig0(0b10...0) + sig1(m_17)
+        {u32_pick(1)}
+        {sig1(xor_depth - 4)}
+
+        {u32_push(0x11002000)} // sig0(0b10...0)
+        {u32_add_drop(0, 1)}
+
+        {u32_pick(16)}
+        {u32_add_drop(0, 1)}
+
+        // i = 20, m_20 = 0b10...0 + sig1(m_18)
+        {u32_pick(1)}
+        {sig1(xor_depth - 3)}
+
+        {u32_push(0x80000000)}
+        {u32_add_drop(0, 1)}
+
+        // i = 21, m_21 = sig1(m_19)
+        {u32_pick(1)}
+        {sig1(xor_depth - 2)}
+
+        // i = 22, m_22 = 640 + sig1(m_20)
+        {u32_pick(1)}
+        {sig1(xor_depth - 1)}
+
+        {u32_push(640)}
+        {u32_add_drop(0, 1)}
+
+        // i = 23..30, m_i = m_{i-7} + sig1(m_{i-2})
+        for i in 23..30 {
+            {u32_pick(1)}
+            {sig1(xor_depth - 6 + i - 16 - 1)}
+
+            {u32_pick(7)}
+            {u32_add_drop(0, 1)}
+        }
+
+        // i = 30, m_30 = sig0(640) + m_23 + sig1(m_28)
+        {u32_pick(1)}
+        {sig1(xor_depth + 7)}
+
+        {u32_pick(7)}
+        {u32_add_drop(0, 1)}
+
+        {u32_push(0x00a00055)}  // sig0(640)
+        {u32_add_drop(0, 1)}
+
+        // i = 31, m_31 = 640 + sig0(m_16) + m_24 + sig1(m_29)
+        {u32_pick(1)}
+        {sig1(xor_depth + 8)}
+
+        {u32_pick(7)}
+        {u32_add_drop(0, 1)}
+
+        {u32_pick(15)}
+        {sig0(xor_depth + 9)}
+        {u32_add_drop(0, 1)}
+
+        {u32_push(640)}
+        {u32_add_drop(0, 1)}
+
+        for i in 32..64 {
+            {u32_pick(1)}
+            {sig1(xor_depth - 6 + i - 16 - 1)}
+
+            {u32_pick(7)}
+            {u32_add_drop(0, 1)}
+
+            {u32_pick(15)}
+            {sig0(xor_depth - 6 + i - 16)}
+            {u32_add_drop(0, 1)}
+
+            {u32_pick(16)}
+            {u32_add_drop(0, 1)}
+        }
+
+        // get a copy of states from altstack
+        for _ in 0..8 {
+            {u32_fromaltstack()}
+        }
+
+        for _ in 0..8 {
+            {u32_pick(7)}
+        }
+
+        for _ in 0..8 {
+            {u32_toaltstack()}
+        }
+
+        // already increase 48 elements in the stack
+        // now loop for transform [h, g, f, e, d, c, b, a]
+        for i in 0..64 {
+            // t1 for reuse
+            {u32_toaltstack()}
+            {u32_toaltstack()}
+            {u32_toaltstack()}
+            {u32_toaltstack()}
+
+            // [h, g, f, e]
+            {u32_roll(3)} // [g, f, e, h]
+            {u32_pick(1)} // [g, f, e, h, e]
+            {ep1(xor_depth+45)}
+            {u32_add_drop(0, 1)} // [g, f, e, tmp_t1]
+            {ch(1, 2, 3, xor_depth+44)}
+            {u32_add_drop(0, 1)}
+
+            {u32_pick(k_depth+44+i)} // pick k
+            {u32_add_drop(0, 1)}
+
+            {u32_pick(4+63-i)} // pick m
+            {u32_add_drop(0, 1)}
+
+            // [g, f, e, t1]
+
+            {u32_dup()}
+            {u32_fromaltstack()} // [g, f, e, t1, t1, d]
+            {u32_add_drop(0, 1)} // [g, f, e, t1, t1 + d]
+
+            {u32_fromaltstack()}
+            {u32_fromaltstack()}
+            {u32_fromaltstack()} // [g, f, e, t1, t1+d, c, b, a]
+            {u32_roll(4)} // [g, f, e, t1+d, c, b, a, t1]
+
+            {u32_pick(1)}
+            {ep0(xor_depth+49)}
+            {u32_add_drop(0, 1)}
+
+            {maj(1, 2, 3, xor_depth+48)}
+            {u32_add_drop(0, 1)}
+            // [g, f, e, t1+d, c, b, a, t1+t2]
+        }
+
+        for _ in 0..8 {
+            {u32_fromaltstack()} // get old state
+        }
+
+        // add new state and old state
+        for i in 0..8 {
+            {u32_roll(8-i)}
+            {u32_add_drop(0, 1)}
+            {u32_toaltstack()}
+        }
+
+        for _ in 0..64 {
+            {u32_drop()} // drop m table
+        }
+
+        for _ in 0..8 {
+            {u32_fromaltstack()}
+        }
+    }
+}
+
+/// Shift right the top u32 element
+pub fn u32_shr(rot_num: usize, stack_depth: u32) -> Script {
+    script! {
+        {u32_rrot(rot_num)}
+        {u32_push(0xffffffff >> rot_num)}
+        {u32_and(0, 1, stack_depth + 1)}
+        {u32_toaltstack()}
+        {u32_drop()}
+        {u32_fromaltstack()}
+    }
+}
+
+/// Change top element x to ROTRIGHT(x,7) ^ ROTRIGHT(x,18) ^ ((x) >> 3)
+pub fn sig0(stack_depth: u32) -> Script {
+    script! {
+        {u32_dup()}
+        {u32_dup()}
+        {u32_toaltstack()}
+        {u32_toaltstack()}
+
+        {u32_shr(3, stack_depth)}
+        {u32_fromaltstack()}
+        {u32_rrot(7)}
+        {u32_fromaltstack()}
+        {u32_rrot(18)}
+        {u32_xor(0, 1, stack_depth + 2)}
+        {u32_xor(0, 2, stack_depth + 2)}
+
+        // clean stack
+        {u32_toaltstack()}
+        {u32_drop()}
+        {u32_drop()}
+        {u32_fromaltstack()}
+    }
+}
+
+/// Change top element x to (ROTRIGHT(x,17) ^ ROTRIGHT(x,19) ^ ((x) >> 10))
+pub fn sig1(stack_depth: u32) -> Script {
+    script! {
+        {u32_dup()}
+        {u32_dup()}
+        {u32_toaltstack()}
+        {u32_toaltstack()}
+
+        {u32_shr(10, stack_depth)}
+        {u32_fromaltstack()}
+        {u32_rrot(19)}
+        {u32_fromaltstack()}
+        {u32_rrot(17)}
+        {u32_xor(0, 1, stack_depth + 2)}
+        {u32_xor(0, 2, stack_depth + 2)}
+
+        // clean stack
+        {u32_toaltstack()}
+        {u32_drop()}
+        {u32_drop()}
+        {u32_fromaltstack()}
+    }
+}
+
+/// Change top element x to (ROTRIGHT(x,2) ^ ROTRIGHT(x,13) ^ ROTRIGHT(x,22))
+pub fn ep0(stack_depth: u32) -> Script {
+    script! {
+        {u32_dup()}
+        {u32_dup()}
+        {u32_toaltstack()}
+        {u32_toaltstack()}
+
+        {u32_rrot(2)}
+        {u32_fromaltstack()}
+        {u32_rrot(13)}
+        {u32_fromaltstack()}
+        {u32_rrot(22)}
+
+        {u32_xor(0, 1, stack_depth+2)}
+        {u32_xor(0, 2, stack_depth+2)}
+
+        // clean stack
+        {u32_toaltstack()}
+        {u32_drop()}
+        {u32_drop()}
+        {u32_fromaltstack()}
+    }
+}
+
+/// Change top element x to (ROTRIGHT(x,6) ^ ROTRIGHT(x,11) ^ ROTRIGHT(x,25))
+pub fn ep1(stack_depth: u32) -> Script {
+    script! {
+        {u32_dup()}
+        {u32_dup()}
+        {u32_toaltstack()}
+        {u32_toaltstack()}
+
+        {u32_rrot(6)}
+        {u32_fromaltstack()}
+        {u32_rrot(11)}
+        {u32_fromaltstack()}
+        {u32_rrot(25)}
+
+        {u32_xor(0, 1, stack_depth+2)}
+        {u32_xor(0, 2, stack_depth+2)}
+
+        // clean stack
+        {u32_toaltstack()}
+        {u32_drop()}
+        {u32_drop()}
+        {u32_fromaltstack()}
+    }
+}
+
+pub fn u32_not() -> Script {
+    script! {
+        for _ in 0..4 {
+            0xff
+            4 OP_ROLL OP_SUB
+        }
+    }
+}
+
+/// Push reversed bytes to the alt stack.
+pub fn push_reverse_bytes_to_alt(num_bytes: usize) -> Script {
+    script! {
+        for i in 1..=num_bytes {
+            {num_bytes-i} OP_ROLL
+            OP_TOALTSTACK
+        }
+    }
+}
+
+/// Push (((x) & (y)) ^ (~(x) & (z))) into stack
+pub fn ch(x: u32, y: u32, z: u32, stack_depth: u32) -> Script {
+    script! {
+        {u32_pick(x)}
+        {u32_pick(y+1)}
+        {u32_and(0, 1, stack_depth+2)}
+        {u32_toaltstack()}
+        {u32_drop()}
+        {u32_fromaltstack()}
+
+        {u32_pick(x+1)}
+        {u32_not()}
+        {u32_pick(z+2)}
+        {u32_and(0, 1, stack_depth+3)}
+        {u32_toaltstack()}
+        {u32_drop()}
+        {u32_fromaltstack()}
+
+        {u32_xor(0, 1, stack_depth+2)}
+        {u32_toaltstack()}
+        {u32_drop()}
+        {u32_fromaltstack()}
+    }
+}
+
+/// Push (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z))) into stack
+pub fn maj(x: u32, y: u32, z: u32, stack_depth: u32) -> Script {
+    script! {
+        {u32_pick(x)}
+        {u32_pick(y+1)}
+        {u32_and(0, 1, stack_depth+2)}
+        {u32_toaltstack()}
+        {u32_drop()}
+        {u32_fromaltstack()}
+
+        {u32_pick(x+1)}
+        {u32_pick(z+2)}
+        {u32_and(0, 1, stack_depth+3)}
+        {u32_toaltstack()}
+        {u32_drop()}
+        {u32_fromaltstack()}
+
+        {u32_pick(y+2)}
+        {u32_pick(z+3)}
+        {u32_and(0, 1, stack_depth+4)}
+        {u32_toaltstack()}
+        {u32_drop()}
+        {u32_fromaltstack()}
+
+        {u32_xor(0, 1, stack_depth+3)}
+        {u32_xor(0, 2, stack_depth+3)}
+
+        // clean stack
+        {u32_toaltstack()}
+        {u32_drop()}
+        {u32_drop()}
+        {u32_fromaltstack()}
+
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::bitvm::hash::utils::push_bytes_hex;
+    use crate::bitvm::hash::sha256::*;
+    use crate::treepp::*;
+    use crate::bitvm::u32::u32_std::{u32_equal, u32_equalverify};
+    use sha2::{Digest, Sha256};
+
+    fn rrot(x: u32, n: usize) -> u32 {
+        if n == 0 {
+            return x;
+        }
+        (x >> n) | (x << (32 - n))
+    }
+
+    #[test]
+    fn test_sha256() {
+        println!("sha256(32): {} bytes", sha256(32).len());
+        println!("sha256(80): {} bytes", sha256(80).len());
+        println!(
+            "sha256 chunk: {} bytes",
+            sha256_transform(8 + 16 + 64 + 1, 8 + 16).len()
+        );
+        let hex_in = "6162636462636465636465666465666765666768666768696768696a68696a6b696a6b6c6a6b6c6d6b6c6d6e6c6d6e6f6d6e6f706e6f70716f7071727071727371727374727374757374757674757677";
+        let mut hasher = Sha256::new();
+        let data = hex::decode(hex_in).unwrap();
+        hasher.update(&data);
+        let mut result = hasher.finalize();
+        hasher = Sha256::new();
+        hasher.update(result);
+        result = hasher.finalize();
+        let res = hex::encode(result);
+        let script = script! {
+            {push_bytes_hex(hex_in)}
+            {sha256(hex_in.len()/2)}
+            {sha256(32)}
+            {push_bytes_hex(res.as_str())}
+            for _ in 0..32 {
+                OP_TOALTSTACK
+            }
+
+            for i in 1..32 {
+                {i}
+                OP_ROLL
+            }
+
+            for _ in 0..32 {
+                OP_FROMALTSTACK
+                OP_EQUALVERIFY
+            }
+            OP_TRUE
+        };
+        let res = execute_script(script);
+        assert!(res.success);
+    }
+
+    #[test]
+    fn test_padding_add_roll() {
+        let hex_in = "6162636462636465636465666465666765666768666768696768696a68696a6b696a6b6c6a6b6c6d6b6c6d6e6c6d6e6f6d6e6f706e6f7071";
+
+        let stack_out: [u32; 32] = [
+            0x61626364, 0x62636465, 0x63646566, 0x64656667, 0x65666768, 0x66676869, 0x6768696a,
+            0x68696a6b, 0x696a6b6c, 0x6a6b6c6d, 0x6b6c6d6e, 0x6c6d6e6f, 0x6d6e6f70, 0x6e6f7071,
+            0x80000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+            0x00000000, 0x00000000, 0x00000000, 0x000001c0,
+        ];
+
+        let script = script! {
+            {push_bytes_hex(hex_in)}
+            {push_reverse_bytes_to_alt(hex_in.len()/2)}
+            {u8_push_xor_table()}
+            {sha256_k()}
+            {padding_add_roll(hex_in.len()/2)}
+            for i in 0..32 {
+                {u32_push(stack_out[i])}
+                {u32_equalverify()} //
+            }
+        };
+        execute_script(script);
+        // assert!(res.success);
+        // println!("result {:100}", res);
+    }
+
+    #[test]
+    fn test_maj() {
+        let x: u32 = 12;
+        let y: u32 = 38;
+        let z: u32 = 97;
+        let result: u32 = (x & y) ^ (x & z) ^ (y & z);
+        let script = script! {
+            {u8_push_xor_table()}
+            {u32_push(z)}
+            {u32_push(y)}
+            {u32_push(x)}
+            {maj(0, 1, 2, 4)}
+            {u32_toaltstack()}
+            {u32_drop()}
+            {u32_drop()}
+            {u32_drop()}
+            {u8_drop_xor_table()}
+            {u32_fromaltstack()}
+
+            {u32_push(result)}
+            {u32_equal()}
+        };
+        let res = execute_script(script);
+        assert!(res.success);
+    }
+
+    #[test]
+    fn test_ch() {
+        let x: u32 = 12;
+        let y: u32 = 38;
+        let z: u32 = 97;
+        let result: u32 = (x & y) ^ ((!x) & z);
+        let script = script! {
+            {u8_push_xor_table()}
+            {u32_push(z)}
+            {u32_push(y)}
+            {u32_push(x)}
+            {ch(0, 1, 2, 4)}
+            {u32_toaltstack()}
+            {u32_drop()}
+            {u32_drop()}
+            {u32_drop()}
+            {u8_drop_xor_table()}
+            {u32_fromaltstack()}
+
+            {u32_push(result)}
+            {u32_equal()}
+        };
+        let res = execute_script(script);
+        assert!(res.success);
+    }
+
+    #[test]
+    fn test_ep1() {
+        let x: u32 = 12;
+        let result: u32 = rrot(x, 6) ^ rrot(x, 11) ^ rrot(x, 25);
+        let script = script! {
+            {u8_push_xor_table()}
+            {u32_push(x)}
+            {ep1(2)}
+            {u32_toaltstack()}
+            {u8_drop_xor_table()}
+            {u32_fromaltstack()}
+
+            {u32_push(result)}
+            {u32_equal()}
+        };
+        let res = execute_script(script);
+        assert!(res.success);
+    }
+
+    #[test]
+    fn test_ep0() {
+        let x: u32 = 12;
+        let result: u32 = rrot(x, 2) ^ rrot(x, 13) ^ rrot(x, 22);
+        let script = script! {
+            {u8_push_xor_table()}
+            {u32_push(x)}
+            {ep0(2)}
+            {u32_toaltstack()}
+            {u8_drop_xor_table()}
+            {u32_fromaltstack()}
+
+            {u32_push(result)}
+            {u32_equal()}
+        };
+        let res = execute_script(script);
+        assert!(res.success);
+    }
+
+    #[test]
+    fn test_sig0() {
+        let x: u32 = 12;
+        let result: u32 = rrot(x, 7) ^ rrot(x, 18) ^ (x >> 3);
+        let script = script! {
+            {u8_push_xor_table()}
+            {u32_push(x)}
+            {sig0(2)}
+            {u32_toaltstack()}
+            {u8_drop_xor_table()}
+            {u32_fromaltstack()}
+
+            {u32_push(result)}
+            {u32_equal()}
+        };
+        let res = execute_script(script);
+        assert!(res.success);
+    }
+
+    #[test]
+    fn test_sig1() {
+        let x: u32 = 12;
+        let result: u32 = rrot(x, 17) ^ rrot(x, 19) ^ (x >> 10);
+        let script = script! {
+            {u8_push_xor_table()}
+            {u32_push(x)}
+            {sig1(2)}
+            {u32_toaltstack()}
+            {u8_drop_xor_table()}
+            {u32_fromaltstack()}
+
+            {u32_push(result)}
+            {u32_equal()}
+        };
+        let res = execute_script(script);
+        assert!(res.success);
+    }
+
+    #[test]
+    fn test_genesis_block() {
+        // the genesis block header of bitcoin
+        // version previous-block merkle-root time bits nonce
+        // 01000000 0000000000000000000000000000000000000000000000000000000000000000 3ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a 29ab5f49 ffff001d 1dac2b7c
+        let block_header = "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a29ab5f49ffff001d1dac2b7c";
+        let mut hasher = Sha256::new();
+        let data = hex::decode(block_header).unwrap();
+        hasher.update(&data);
+        let mut result = hasher.finalize();
+        hasher = Sha256::new();
+        hasher.update(result);
+        result = hasher.finalize();
+        let res = hex::encode(result);
+        let genesis_block_hash = "6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000";
+        assert_eq!(res.as_str(), genesis_block_hash);
+        let script = script! {
+            {push_bytes_hex(block_header)}
+            {sha256(80)}
+            {sha256(32)}
+            {push_bytes_hex(res.as_str())}
+            for _ in 0..32 {
+                OP_TOALTSTACK
+            }
+
+            for i in 1..32 {
+                {i}
+                OP_ROLL
+            }
+
+            for _ in 0..32 {
+                OP_FROMALTSTACK
+                OP_EQUALVERIFY
+            }
+            OP_TRUE
+        };
+        let res = execute_script(script);
+        assert!(res.success);
+    }
+}
\ No newline at end of file
diff --git a/splitter/src/bitvm/hash/utils.rs b/splitter/src/bitvm/hash/utils.rs
new file mode 100644
index 0000000..67d9296
--- /dev/null
+++ b/splitter/src/bitvm/hash/utils.rs
@@ -0,0 +1,19 @@
+use crate::treepp::*;
+
+pub fn push_bytes_hex(hex: &str) -> Script {
+    let hex: String = hex
+        .chars()
+        .filter(|c| c.is_ascii_digit() || c.is_ascii_alphabetic())
+        .collect();
+
+    let bytes: Vec<u8> = (0..hex.len())
+        .step_by(2)
+        .map(|i| u8::from_str_radix(&hex[i..i + 2], 16).unwrap())
+        .collect::<Vec<u8>>();
+
+    script! {
+        for byte in bytes.iter().rev() {
+            { *byte }
+        }
+    }
+}
\ No newline at end of file
diff --git a/splitter/src/bitvm/mod.rs b/splitter/src/bitvm/mod.rs
new file mode 100644
index 0000000..13fb514
--- /dev/null
+++ b/splitter/src/bitvm/mod.rs
@@ -0,0 +1,5 @@
+//! Package that contains the implementation of certain test
+//! scripts from BitVM2 that are used to test the functionality of the splitter.
+
+pub(crate) mod u32;
+pub(crate) mod hash;
\ No newline at end of file
diff --git a/splitter/src/bitvm/u32/mod.rs b/splitter/src/bitvm/u32/mod.rs
new file mode 100644
index 0000000..afa2667
--- /dev/null
+++ b/splitter/src/bitvm/u32/mod.rs
@@ -0,0 +1,6 @@
+pub mod u32_add;
+pub mod u32_and;
+pub mod u32_std;
+pub mod u32_xor;
+pub mod u32_rrot;
+pub mod u32_zip;
\ No newline at end of file
diff --git a/splitter/src/bitvm/u32/u32_add.rs b/splitter/src/bitvm/u32/u32_add.rs
new file mode 100644
index 0000000..b0730fc
--- /dev/null
+++ b/splitter/src/bitvm/u32/u32_add.rs
@@ -0,0 +1,129 @@
+use crate::treepp::*;
+use crate::bitvm::u32::u32_zip::{u32_copy_zip, u32_zip};
+
+pub fn u8_add_carry() -> Script {
+    script! {
+        OP_ADD
+        OP_DUP
+        255
+        OP_GREATERTHAN
+        OP_IF
+            256
+            OP_SUB
+            1
+        OP_ELSE
+            0
+        OP_ENDIF
+    }
+}
+
+pub fn u8_add() -> Script {
+    script! {
+        OP_ADD
+        OP_DUP
+        255
+        OP_GREATERTHAN
+        OP_IF
+            256
+            OP_SUB
+        OP_ENDIF
+    }
+}
+
+/// Addition of two u32 values represented as u8
+/// Copies the first summand `a` and drops `b`
+pub fn u32_add(a: u32, b: u32) -> Script {
+    assert_ne!(a, b);
+    script! {
+        {u32_copy_zip(a, b)}
+
+        // A0 + B0
+        u8_add_carry
+        OP_SWAP
+        OP_TOALTSTACK
+
+        // A1 + B1 + carry_0
+        OP_ADD
+        u8_add_carry
+        OP_SWAP
+        OP_TOALTSTACK
+
+        // A2 + B2 + carry_1
+        OP_ADD
+        u8_add_carry
+        OP_SWAP
+        OP_TOALTSTACK
+
+        // A3 + B3 + carry_2
+        OP_ADD
+        u8_add
+
+        OP_FROMALTSTACK
+        OP_FROMALTSTACK
+        OP_FROMALTSTACK
+
+        // Now there's the result C_3 C_2 C_1 C_0 on the stack
+    }
+}
+
+/// Addition of two u32 values represented as u8
+/// Drops both summands `a` and `b`
+pub fn u32_add_drop(a: u32, b: u32) -> Script {
+    assert_ne!(a, b);
+    script! {
+        {u32_zip(a, b)}
+
+        // A0 + B0
+        u8_add_carry
+        OP_SWAP
+        OP_TOALTSTACK
+
+        // A1 + B1 + carry_0
+        OP_ADD
+        u8_add_carry
+        OP_SWAP
+        OP_TOALTSTACK
+
+        // A2 + B2 + carry_1
+        OP_ADD
+        u8_add_carry
+        OP_SWAP
+        OP_TOALTSTACK
+
+        // A3 + B3 + carry_2
+        OP_ADD
+        u8_add
+
+        OP_FROMALTSTACK
+        OP_FROMALTSTACK
+        OP_FROMALTSTACK
+
+        // Now there's the result C_3 C_2 C_1 C_0 on the stack
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::debug::run_and_assert;
+    use crate::treepp::script;
+    use crate::bitvm::u32::u32_add::*;
+    use crate::bitvm::u32::u32_std::u32_push;
+
+    #[test]
+    fn test_u32_add() {
+        let u32_value_a = 0xFFEEFFEEu32;
+        let u32_value_b = 0xEEFFEEFFu32;
+
+        let script = script! {
+            { u32_push(u32_value_a) }
+            { u32_push(u32_value_b) }
+            { u32_add_drop(1, 0) }
+            0xed OP_EQUALVERIFY
+            0xee OP_EQUALVERIFY
+            0xee OP_EQUALVERIFY
+            0xee OP_EQUAL
+        };
+        
+        run_and_assert(script);
+    }
+}
\ No newline at end of file
diff --git a/splitter/src/bitvm/u32/u32_and.rs b/splitter/src/bitvm/u32/u32_and.rs
new file mode 100644
index 0000000..c0c7a26
--- /dev/null
+++ b/splitter/src/bitvm/u32/u32_and.rs
@@ -0,0 +1,132 @@
+#![allow(dead_code)]
+
+use crate::treepp::*;
+use crate::bitvm::u32::u32_zip::u32_copy_zip;
+
+/// The bitwise AND of two u8 elements.
+/// Expects the u8_xor_table to be on the stack
+pub fn u8_and(i: u32) -> Script {
+    script! {
+        // f_A = f(A)
+        OP_DUP
+        {i}
+        OP_ADD
+        OP_PICK
+
+        // A_even = f_A << 1
+        OP_DUP
+        OP_DUP
+        OP_ADD
+
+        // A_odd = A - A_even
+        OP_ROT
+        OP_SWAP
+        OP_SUB
+
+        // f_B = f(B)
+        OP_ROT
+        OP_DUP
+        {i + 1}
+        OP_ADD
+        OP_PICK
+
+        // B_even = f_B << 1
+        OP_DUP
+        OP_DUP
+        OP_ADD
+
+        // B_odd = B - B_even
+        OP_ROT
+        OP_SWAP
+        OP_SUB
+
+        // A_andxor_B_even = f_A + f_B
+        OP_SWAP
+        3
+        OP_ROLL
+        OP_ADD
+        // A_and_B_even = f(A_andxor_B_even)
+        {i}
+        OP_ADD
+        OP_PICK
+
+        // A_andxor_B_odd = A_odd + B_odd
+        OP_SWAP
+        OP_ROT
+        OP_ADD
+
+        // A_and_B_odd = f(A_andxor_B_odd)
+        {i - 1}
+        OP_ADD
+        OP_PICK
+
+        // A_and_B = A_and_B_odd + (A_and_B_even << 1)
+        OP_OVER
+        OP_ADD
+        OP_ADD
+    }
+}
+
+/// The bitwise AND of the u32 elements at address a and at address b. Drops a and b
+///
+/// Expects the u8_xor_table to be on the stack
+pub fn u32_and(a: u32, b: u32, stack_size: u32) -> Script {
+    assert_ne!(a, b);
+    script! {
+        {u32_copy_zip(a, b)}
+
+        {u8_and(8 + (stack_size - 2) * 4)}
+
+        OP_TOALTSTACK
+
+        {u8_and(6 + (stack_size - 2) * 4)}
+
+        OP_TOALTSTACK
+
+        {u8_and(4 + (stack_size - 2) * 4)}
+
+        OP_TOALTSTACK
+
+        {u8_and(2 + (stack_size - 2) * 4)}
+
+        OP_FROMALTSTACK
+        OP_FROMALTSTACK
+        OP_FROMALTSTACK
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::debug::run_and_assert;
+    use crate::treepp::script;
+    use crate::bitvm::u32::u32_and::*;
+    use crate::bitvm::u32::u32_std::*;
+    use crate::bitvm::u32::u32_xor::{u8_drop_xor_table, u8_push_xor_table};
+    use rand::Rng;
+
+    fn and(x: u32, y: u32) -> u32 { x & y }
+
+    #[test]
+    fn test_and() {
+        println!("u32 and: {} bytes", u32_and(0, 1, 3).len());
+        for _ in 0..100 {
+            let mut rng = rand::thread_rng();
+            let x: u32 = rng.gen();
+            let y: u32 = rng.gen();
+            let exec_script = script! {
+                {u8_push_xor_table()}
+                {u32_push(x)}
+                {u32_push(y)}
+                {u32_and(0, 1, 3)}
+                {u32_push(and(x, y))}
+                {u32_equal()}
+                OP_TOALTSTACK
+                {u32_drop()} // drop y
+                {u8_drop_xor_table()}
+                OP_FROMALTSTACK
+            };
+            run_and_assert(exec_script);
+        }
+    }
+}
\ No newline at end of file
diff --git a/splitter/src/bitvm/u32/u32_rrot.rs b/splitter/src/bitvm/u32/u32_rrot.rs
new file mode 100644
index 0000000..3ec7afe
--- /dev/null
+++ b/splitter/src/bitvm/u32/u32_rrot.rs
@@ -0,0 +1,258 @@
+#![allow(dead_code)]
+
+use crate::treepp::*;
+use core::panic;
+
+/// Right rotation of an u32 element by 16 bits
+pub fn u32_rrot16() -> Script {
+    script! {
+      OP_2SWAP
+    }
+}
+
+/// Right rotation of an u32 element by 8 bits
+pub fn u32_rrot8() -> Script {
+    script! {
+      OP_2SWAP
+      3 OP_ROLL
+    }
+}
+
+/// Right rotation of an u8 element by 7 bits
+pub fn u8_rrot7(i: u32) -> Script {
+    let roll_script = match i {
+        0 => script! {},
+        1 => script! { OP_SWAP },
+        2 => script! { OP_ROT },
+        _ => script! { {i} OP_ROLL },
+    };
+    script! {
+        { roll_script }
+        128
+        OP_2DUP
+        OP_GREATERTHANOREQUAL
+        OP_IF
+            OP_SUB
+            1
+        OP_ELSE
+            OP_DROP
+            0
+        OP_ENDIF
+    }
+}
+
+/// Right rotation of an u32 element by 7 bits
+pub fn u32_rrot7() -> Script {
+    script! {
+        // First Byte
+        {u8_rrot7(0)}
+
+        // Second byte
+        {u8_rrot7(2)}
+
+        OP_TOALTSTACK
+        OP_DUP
+        OP_ADD
+        OP_ADD
+        OP_FROMALTSTACK
+
+        // Third byte
+        {u8_rrot7(3)}
+
+        OP_TOALTSTACK
+        OP_DUP
+        OP_ADD
+        OP_ADD
+        OP_FROMALTSTACK
+
+        // Fourth byte
+        {u8_rrot7(4)}
+
+        OP_TOALTSTACK
+        OP_DUP
+        OP_ADD
+        OP_ADD
+        OP_FROMALTSTACK
+
+        // Close the circle
+        4 OP_ROLL
+        OP_DUP
+        OP_ADD
+        OP_ADD
+
+        OP_SWAP
+        OP_2SWAP
+        OP_SWAP
+    }
+}
+
+pub fn u8_extract_1bit() -> Script {
+    script! {
+        OP_DUP
+        OP_ADD
+        256
+        OP_2DUP
+        OP_GREATERTHANOREQUAL
+        OP_IF
+            OP_SUB
+            1
+        OP_ELSE
+            OP_DROP
+            0
+        OP_ENDIF
+    }
+}
+
+pub fn u8_extract_hbit(hbit: usize) -> Script {
+    assert!(hbit < 8 && hbit != 0);
+    if hbit == 1 {
+        return u8_extract_1bit();
+    }
+    let base: usize = 2;
+    let x: usize = base.pow((hbit - 1).try_into().unwrap());
+    script! {
+        0
+        OP_TOALTSTACK
+
+        for i in 0..hbit
+        {
+            OP_DUP
+            127
+            OP_GREATERTHAN
+            OP_IF
+                128
+                OP_SUB
+                OP_FROMALTSTACK
+                { x >> i }
+                OP_ADD
+                OP_TOALTSTACK
+            OP_ENDIF
+
+            OP_DUP
+            OP_ADD
+        }
+
+        OP_FROMALTSTACK
+    }
+}
+// 1 2 3 4
+pub fn byte_reorder(offset: usize) -> Script {
+    assert!(offset < 4);
+    if offset == 0 {
+        // 4 3 2 1
+        script! {
+            OP_SWAP
+            OP_2SWAP
+            OP_SWAP
+        }
+    } else if offset == 1 {
+        // 1 4 3 2
+        return script! {
+            OP_SWAP
+            OP_ROT
+        };
+    } else if offset == 2 {
+        // 2 1 4 3
+        return script! {
+            OP_SWAP
+            OP_2SWAP
+            OP_SWAP
+            OP_2SWAP
+        };
+    } else if offset == 3 {
+        return script! {
+            OP_SWAP
+            OP_ROT
+            OP_2SWAP
+        };
+    } else {
+        panic!("offset out of range")
+    }
+}
+
+pub fn specific_optimize(rot_num: usize) -> Option<Script> {
+    let res: Option<Script> = match rot_num {
+        0 => script! {}.into(),            // 0
+        7 => script! {u32_rrot7}.into(),   // 76
+        8 => script! {u32_rrot8}.into(),   // 3
+        16 => script! {u32_rrot16}.into(), // 1
+        23 => script! {u32_rrot16 u32_rrot7}.into(),
+        24 => script! {3 OP_ROLL}.into(), // 2
+        _ => None,
+    };
+    res
+}
+
+pub fn u32_rrot(rot_num: usize) -> Script {
+    assert!(rot_num < 32);
+    if let Some(res) = specific_optimize(rot_num) {
+        return res;
+    }
+    let remainder: usize = rot_num % 8;
+
+    let hbit: usize = 8 - remainder;
+    let offset: usize = (rot_num - remainder) / 8;
+
+    script! {
+        {u8_extract_hbit(hbit)}
+        OP_ROT {u8_extract_hbit(hbit)}
+        4 OP_ROLL {u8_extract_hbit(hbit)}
+        6 OP_ROLL {u8_extract_hbit(hbit)}
+
+        7 OP_ROLL
+        OP_ADD
+        OP_TOALTSTACK
+
+        OP_ADD
+        OP_TOALTSTACK
+
+        OP_ADD
+        OP_TOALTSTACK
+
+        OP_ADD
+        OP_TOALTSTACK
+
+        OP_FROMALTSTACK
+        OP_FROMALTSTACK
+        OP_FROMALTSTACK
+        OP_FROMALTSTACK
+        {byte_reorder(offset)}
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::debug::run_and_assert;
+    use crate::treepp::script;
+    use crate::bitvm::u32::u32_rrot::*;
+    use crate::bitvm::u32::u32_std::*;
+    use rand::Rng;
+
+    fn rrot(x: u32, n: usize) -> u32 {
+        if n == 0 {
+            return x;
+        }
+        (x >> n) | (x << (32 - n))
+    }
+
+    #[test]
+    fn test_rrot() {
+        for i in 0..32 {
+            println!("u32_rrot({}): {} bytes", i, u32_rrot(i).len());
+        }
+        for _ in 0..100 {
+            let mut rng = rand::thread_rng();
+            let x: u32 = rng.gen();
+            for i in 0..32 {
+                let script = script! {
+                    {u32_push(x)}
+                    {u32_rrot(i)}
+                    {u32_push(rrot(x, i))}
+                    {u32_equal()}
+                };
+                run_and_assert(script);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/splitter/src/bitvm/u32/u32_std.rs b/splitter/src/bitvm/u32/u32_std.rs
new file mode 100644
index 0000000..d50ea1b
--- /dev/null
+++ b/splitter/src/bitvm/u32/u32_std.rs
@@ -0,0 +1,214 @@
+#![allow(dead_code)]
+
+use crate::pseudo::{push_to_stack, OP_256MUL, OP_4DUP};
+
+use crate::treepp::*;
+
+/// Pushes a value as u32 element onto the stack
+pub fn u32_push(value: u32) -> Script {
+    script! {
+        //optimization
+        if (value >> 24 & 0xff) == (value >> 16 & 0xff) &&
+            (value >> 24 & 0xff) == (value >> 8 & 0xff) &&
+            (value >> 24 & 0xff) == (value & 0xff) {
+
+                { push_to_stack((value >> 24 & 0xff) as usize,4) }
+        }
+        else{
+
+                {value >> 24 & 0xff}
+                {value >> 16 & 0xff}
+                {value >>  8 & 0xff}
+                {value & 0xff}
+        }
+    }
+}
+
+/// Marks transaction as invalid if the top two stack value are not equal
+pub fn u32_equalverify() -> Script {
+    script! {
+        4
+        OP_ROLL
+        OP_EQUALVERIFY
+        3
+        OP_ROLL
+        OP_EQUALVERIFY
+        OP_ROT
+        OP_EQUALVERIFY
+        OP_EQUALVERIFY
+    }
+}
+/// Returns 1 if the top two u32 are equal, 0 otherwise
+pub fn u32_equal() -> Script {
+    script! {
+        4
+        OP_ROLL
+        OP_EQUAL OP_TOALTSTACK
+        3
+        OP_ROLL
+        OP_EQUAL OP_TOALTSTACK
+        OP_ROT
+        OP_EQUAL OP_TOALTSTACK
+        OP_EQUAL
+        OP_FROMALTSTACK OP_BOOLAND
+        OP_FROMALTSTACK OP_BOOLAND
+        OP_FROMALTSTACK OP_BOOLAND
+    }
+}
+
+/// Returns 1 if the top two u32 are not equal, 0 otherwise
+pub fn u32_notequal() -> Script {
+    script! {
+        4
+        OP_ROLL
+        OP_NUMNOTEQUAL OP_TOALTSTACK
+        3
+        OP_ROLL
+        OP_NUMNOTEQUAL OP_TOALTSTACK
+        OP_ROT
+        OP_NUMNOTEQUAL OP_TOALTSTACK
+        OP_NUMNOTEQUAL
+        OP_FROMALTSTACK OP_BOOLOR
+        OP_FROMALTSTACK OP_BOOLOR
+        OP_FROMALTSTACK OP_BOOLOR
+    }
+}
+
+/// Puts the top u32 element onto the top of the alt stack. Removes it from the main stack.
+pub fn u32_toaltstack() -> Script {
+    script! {
+        OP_TOALTSTACK
+        OP_TOALTSTACK
+        OP_TOALTSTACK
+        OP_TOALTSTACK
+    }
+}
+
+/// Puts the top u32 element of the alt stack onto the top of the main stack. Removes it from the alt stack.
+pub fn u32_fromaltstack() -> Script {
+    script! {
+        OP_FROMALTSTACK
+        OP_FROMALTSTACK
+        OP_FROMALTSTACK
+        OP_FROMALTSTACK
+    }
+}
+
+/// Duplicates the top u32 stack element
+pub fn u32_dup() -> Script {
+    script! { OP_4DUP }
+}
+
+/// Removes the top u32 element from the stack.
+pub fn u32_drop() -> Script {
+    script! {
+        OP_2DROP
+        OP_2DROP
+    }
+}
+
+/// The u32 element n back in the stack is moved to the top.
+pub fn u32_roll(n: u32) -> Script {
+    let n = (n + 1) * 4 - 1;
+    script! {
+        {n} OP_ROLL
+        {n} OP_ROLL
+        {n} OP_ROLL
+        {n} OP_ROLL
+    }
+}
+
+/// The u32 element n back in the stack is copied to the top.
+pub fn u32_pick(n: u32) -> Script {
+    let n = (n + 1) * 4 - 1;
+    script! {
+        {n} OP_PICK
+        {n} OP_PICK
+        {n} OP_PICK
+        {n} OP_PICK
+    }
+}
+
+/// The top u32 element is compressed into a single 4-byte word
+pub fn u32_compress() -> Script {
+    script! {
+        OP_SWAP
+        OP_ROT
+        3
+        OP_ROLL
+        OP_DUP
+        127
+        OP_GREATERTHAN
+        OP_IF
+            128
+            OP_SUB
+            1
+        OP_ELSE
+            0
+        OP_ENDIF
+        OP_TOALTSTACK
+        OP_256MUL
+        OP_ADD
+        OP_256MUL
+        OP_ADD
+        OP_256MUL
+        OP_ADD
+        OP_FROMALTSTACK
+        OP_IF
+            OP_NEGATE
+        OP_ENDIF
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::debug::run_and_assert;
+    use crate::treepp::script;
+    use crate::bitvm::u32::u32_std::*;
+    use rand::Rng;
+
+    #[test]
+    fn test_u32_push() {
+        let script = script! {
+            { u32_push(0x01020304) }
+            0x04
+            OP_EQUALVERIFY
+            0x03
+            OP_EQUALVERIFY
+            0x02
+            OP_EQUALVERIFY
+            0x01
+            OP_EQUAL
+        };
+
+        run_and_assert(script);
+    }
+
+    #[test]
+    fn test_with_u32_compress() {
+        let mut rng = rand::thread_rng();
+
+        for _ in 0..30 {
+            let mut origin_value0: u32 = rng.gen();
+            origin_value0 = (origin_value0 % 1) << 31;
+            let mut origin_value1: u32 = rng.gen();
+            origin_value1 = (origin_value1 % 1) << 31;
+
+            let v = origin_value0 + origin_value1;
+
+            let script = script! {
+                { u32_push(origin_value0)}
+                { u32_compress()}
+                { u32_push(origin_value1)}
+                { u32_compress()}
+                OP_ADD
+                { u32_push(v)}
+                { u32_compress()}
+                OP_EQUAL
+
+            };
+
+            run_and_assert(script);
+        }
+    }
+}
\ No newline at end of file
diff --git a/splitter/src/bitvm/u32/u32_xor.rs b/splitter/src/bitvm/u32/u32_xor.rs
new file mode 100644
index 0000000..87e1b07
--- /dev/null
+++ b/splitter/src/bitvm/u32/u32_xor.rs
@@ -0,0 +1,373 @@
+#![allow(dead_code)]
+
+use crate::treepp::*;
+use crate::bitvm::u32::u32_zip::u32_copy_zip;
+
+/// Bitwise XOR of two u8 elements
+///
+/// Expects the u8_xor_table on the stack
+///
+/// Explanation of the algorithm: https://github.com/BitVM/BitVM/blob/main/tapscripts/docs/u8_xor.md
+pub fn u8_xor(i: u32) -> Script {
+    script! {
+        // f_A = f(A)
+        OP_DUP
+        {i}
+        OP_ADD
+        OP_PICK
+
+        // A_even = f_A << 1
+        OP_DUP
+        OP_DUP
+        OP_ADD
+
+        // A_odd = A - A_even
+        OP_ROT
+        OP_SWAP
+        OP_SUB
+
+        // f_B = f(B)
+        OP_ROT
+        OP_DUP
+        {i + 1}
+        OP_ADD
+        OP_PICK
+
+        // B_even = f_B << 1
+        OP_DUP
+        OP_DUP
+        OP_ADD
+
+        // B_odd = B - B_even
+        OP_ROT
+        OP_SWAP
+        OP_SUB
+
+        // A_andxor_B_even = f_A + f_B
+        OP_SWAP
+        3
+        OP_ROLL
+        OP_ADD
+
+        // A_xor_B_even = A_andxor_B_even - (f(A_andxor_B_even) << 1)
+        OP_DUP
+        {i + 1}
+        OP_ADD
+        OP_PICK
+        OP_DUP
+        OP_ADD
+        OP_SUB
+
+        // A_andxor_B_odd = A_odd + B_odd
+        OP_SWAP
+        OP_ROT
+        OP_ADD
+
+        // A_xor_B_odd = A_andxor_B_odd - (f(A_andxor_B_odd) << 1)
+        OP_DUP
+        {i}
+        OP_ADD
+        OP_PICK
+        OP_DUP
+        OP_ADD
+        OP_SUB
+
+        // A_xor_B = A_xor_B_odd + (A_xor_B_even << 1)
+        OP_OVER
+        OP_ADD
+        OP_ADD
+    }
+}
+
+/// Bitwise XOR of two u32 elements
+///
+/// Expects u8_xor_table on the stack
+pub fn u32_xor(a: u32, b: u32, stack_size: u32) -> Script {
+    assert_ne!(a, b);
+    script! {
+        {u32_copy_zip(a, b)}
+
+        //
+        // XOR
+        //
+
+        {u8_xor(8 + (stack_size - 2) * 4)}
+
+        OP_TOALTSTACK
+
+        {u8_xor(6 + (stack_size - 2) * 4)}
+
+        OP_TOALTSTACK
+
+        {u8_xor(4 + (stack_size - 2) * 4)}
+
+        OP_TOALTSTACK
+
+        {u8_xor(2 + (stack_size - 2) * 4)}
+
+
+        OP_FROMALTSTACK
+        OP_FROMALTSTACK
+        OP_FROMALTSTACK
+    }
+}
+
+/// Push the u8 XOR table
+///
+/// It's a lookup table for the function f(x) = (x & 0b10101010) >> 1
+pub fn u8_push_xor_table() -> Script {
+    script! {
+        85
+        OP_DUP
+        84
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+        81
+        OP_DUP
+        80
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+
+        85
+        OP_DUP
+        84
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+        81
+        OP_DUP
+        80
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+
+        69
+        OP_DUP
+        68
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+        65
+        OP_DUP
+        64
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+
+        69
+        OP_DUP
+        68
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+        65
+        OP_DUP
+        64
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+
+        85
+        OP_DUP
+        84
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+        81
+        OP_DUP
+        80
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+
+        85
+        OP_DUP
+        84
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+        81
+        OP_DUP
+        80
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+
+        69
+        OP_DUP
+        68
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+        65
+        OP_DUP
+        64
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+
+        69
+        OP_DUP
+        68
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+        65
+        OP_DUP
+        64
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+
+        21
+        OP_DUP
+        20
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+        17
+        OP_DUP
+        16
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+
+        21
+        OP_DUP
+        20
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+        17
+        OP_DUP
+        16
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+
+        5
+        OP_DUP
+        4
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+        1
+        OP_DUP
+        0
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+
+        5
+        OP_DUP
+        4
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+        1
+        OP_DUP
+        0
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+
+        21
+        OP_DUP
+        20
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+        17
+        OP_DUP
+        16
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+
+        21
+        OP_DUP
+        20
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+        17
+        OP_DUP
+        16
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+
+        5
+        OP_DUP
+        4
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+        1
+        OP_DUP
+        0
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+
+        5
+        OP_DUP
+        4
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+        1
+        OP_DUP
+        0
+        OP_DUP
+        OP_2OVER
+        OP_2OVER
+    }
+}
+
+/// Drop the u8 XOR table
+pub fn u8_drop_xor_table() -> Script {
+    script! {
+        for _ in 0..128{
+            OP_2DROP
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::debug::run_and_assert;
+    use crate::treepp::*;
+    use crate::bitvm::u32::u32_std::*;
+    use crate::bitvm::u32::u32_xor::{u32_xor, u8_drop_xor_table, u8_push_xor_table};
+    use rand::Rng;
+
+    fn xor(x: u32, y: u32) -> u32 { x ^ y }
+
+    #[test]
+    fn test_xor() {
+        println!("u32 xor: {} bytes", u32_xor(0, 1, 3).len());
+        for _ in 0..100 {
+            let mut rng = rand::thread_rng();
+            let x: u32 = rng.gen();
+            let y: u32 = rng.gen();
+            let script = script! {
+                {u8_push_xor_table()}
+                {u32_push(x)}
+                {u32_push(y)}
+                {u32_xor(0, 1, 3)}
+                {u32_push(xor(x, y))}
+                {u32_equal()}
+                OP_TOALTSTACK
+                {u32_drop()} // drop y
+                {u8_drop_xor_table()}
+                OP_FROMALTSTACK
+            };
+
+            run_and_assert(script);
+        }
+    }
+}
\ No newline at end of file
diff --git a/splitter/src/bitvm/u32/u32_zip.rs b/splitter/src/bitvm/u32/u32_zip.rs
new file mode 100644
index 0000000..289e41f
--- /dev/null
+++ b/splitter/src/bitvm/u32/u32_zip.rs
@@ -0,0 +1,59 @@
+#![allow(dead_code)]
+use crate::treepp::*;
+
+/// Zip the top two u32 elements
+/// input:  a0 a1 a2 a3 b0 b1 b2 b3
+/// output: a0 b0 a1 b1 a2 b2 a3 b3
+pub fn u32_zip(mut a: u32, mut b: u32) -> Script {
+    if a > b {
+        (a, b) = (b, a);
+    }
+
+    a = (a + 1) * 4 - 1;
+    b = (b + 1) * 4 - 1;
+
+    script! {
+        {a} OP_ROLL {b} OP_ROLL
+        {a+1} OP_ROLL {b} OP_ROLL
+        {a+2} OP_ROLL {b} OP_ROLL
+        {a+3} OP_ROLL {b} OP_ROLL
+    }
+}
+
+/// Copy and zip the top two u32 elements
+/// input:  a0 a1 a2 a3 b0 b1 b2 b3
+/// output: a0 b0 a1 b1 a2 b2 a3 b3 a0 a1 a2 a3
+pub fn u32_copy_zip(a: u32, b: u32) -> Script {
+    if a < b {
+        _u32_copy_zip(a, b)
+    } else {
+        _u32_zip_copy(b, a)
+    }
+}
+
+pub fn _u32_copy_zip(mut a: u32, mut b: u32) -> Script {
+    assert!(a < b);
+
+    a = (a + 1) * 4 - 1;
+    b = (b + 1) * 4 - 1;
+
+    script! {
+        {a} OP_PICK {b+1} OP_ROLL
+        {a+1} OP_PICK {b+2} OP_ROLL
+        {a+2} OP_PICK {b+3} OP_ROLL
+        {a+3} OP_PICK {b+4} OP_ROLL
+    }
+}
+
+pub fn _u32_zip_copy(mut a: u32, mut b: u32) -> Script {
+    assert!(a < b);
+
+    a = (a + 1) * 4 - 1;
+    b = (b + 1) * 4 - 1;
+    script! {
+        {a} OP_ROLL {b} OP_PICK
+        {a+1} OP_ROLL {b} OP_PICK
+        {a+2} OP_ROLL {b} OP_PICK
+        {a+3} OP_ROLL {b} OP_PICK
+    }
+}
\ No newline at end of file
diff --git a/splitter/src/debug.rs b/splitter/src/debug.rs
index 62ac034..23872a5 100644
--- a/splitter/src/debug.rs
+++ b/splitter/src/debug.rs
@@ -1,6 +1,7 @@
 use bitcoin::{hashes::Hash, ScriptBuf, TapLeafHash, Transaction};
 use bitcoin_scriptexec::{Exec, ExecCtx, ExecError, ExecStats, Options, Stack, TxTemplate};
 use core::fmt;
+use crate::treepp;
 
 /// Information about the status of the script execution.
 #[derive(Debug)]
@@ -126,6 +127,16 @@ pub fn execute_script_no_stack_limit(script: bitcoin::ScriptBuf) -> ExecuteInfo
     }
 }
 
+/// Run the given script and panic if the script execution fails.
+pub fn run_and_assert(script: treepp::Script) {
+    let exec_result = execute_script(script);
+    if !exec_result.success {
+        println!("Script execution failed!");
+    }
+
+    assert!(exec_result.success, "Script execution failed!");
+}
+
 #[cfg(test)]
 mod test {
     use super::execute_script_no_stack_limit;
diff --git a/splitter/src/lib.rs b/splitter/src/lib.rs
index 734bae2..e6622a8 100644
--- a/splitter/src/lib.rs
+++ b/splitter/src/lib.rs
@@ -10,7 +10,9 @@ pub mod treepp {
 
 pub mod split;
 
+pub(crate) mod bitvm;
 pub(crate) mod debug;
+pub(crate) mod pseudo;
 pub(crate) mod test_scripts;
 pub(crate) mod utils;
 
diff --git a/splitter/src/pseudo.rs b/splitter/src/pseudo.rs
new file mode 100644
index 0000000..f71ad08
--- /dev/null
+++ b/splitter/src/pseudo.rs
@@ -0,0 +1,169 @@
+#![allow(non_snake_case)]
+#![allow(dead_code)]
+
+use crate::treepp::*;
+
+pub fn OP_CHECKSEQUENCEVERIFY() -> Script {
+    script! {OP_CSV}
+}
+
+/// OP_4PICK
+/// The 4 items n back in the stack are copied to the top.
+pub fn OP_4PICK() -> Script {
+    script! {
+        OP_ADD
+        OP_DUP  OP_PICK OP_SWAP
+        OP_DUP  OP_PICK OP_SWAP
+        OP_DUP  OP_PICK OP_SWAP
+        OP_1SUB OP_PICK
+    }
+}
+
+/// OP_4ROLL
+/// The 4 items n back in the stack are moved to the top.
+pub fn OP_4ROLL() -> Script {
+    script! {
+        4 OP_ADD
+        OP_DUP  OP_ROLL OP_SWAP
+        OP_DUP  OP_ROLL OP_SWAP
+        OP_DUP  OP_ROLL OP_SWAP
+        OP_1SUB OP_ROLL
+    }
+}
+
+/// Duplicates the top 4 items
+pub fn OP_4DUP() -> Script {
+    script! {
+        OP_2OVER OP_2OVER
+    }
+}
+
+/// Drops the top 4 items
+pub fn OP_4DROP() -> Script {
+    script! {
+        OP_2DROP OP_2DROP
+    }
+}
+
+/// Swaps the top two groups of 4 items
+pub fn OP_4SWAP() -> Script {
+    script! {
+        7 OP_ROLL 7 OP_ROLL
+        7 OP_ROLL 7 OP_ROLL
+    }
+}
+
+/// Puts the top 4 items onto the top of the alt stack. Removes them from the main stack.
+pub fn OP_4TOALTSTACK() -> Script {
+    script! {
+        OP_TOALTSTACK OP_TOALTSTACK OP_TOALTSTACK OP_TOALTSTACK
+    }
+}
+
+/// Puts the top 4 items from the altstack onto the top of the main stack. Removes them from the alt stack.
+pub fn OP_4FROMALTSTACK() -> Script {
+    script! {
+        OP_FROMALTSTACK OP_FROMALTSTACK OP_FROMALTSTACK OP_FROMALTSTACK
+    }
+}
+
+//
+// Multiplication by Powers of 2
+//
+
+/// The top stack item is multiplied by 2
+pub fn OP_2MUL() -> Script {
+    script! {
+        OP_DUP OP_ADD
+    }
+}
+
+/// The top stack item is multiplied by 4
+pub fn OP_4MUL() -> Script {
+    script! {
+        OP_DUP OP_ADD OP_DUP OP_ADD
+    }
+}
+
+/// The top stack item is multiplied by 2**k
+pub fn op_2k_mul(k: u32) -> Script {
+    script! {
+        for _ in 0..k{
+            {OP_2MUL()}
+        }
+    }
+}
+
+/// The top stack item is multiplied by 16
+pub fn OP_16MUL() -> Script {
+    script! {
+        OP_DUP OP_ADD OP_DUP OP_ADD
+        OP_DUP OP_ADD OP_DUP OP_ADD
+    }
+}
+
+/// The top stack item is multiplied by 256
+pub fn OP_256MUL() -> Script {
+    script! {
+        OP_DUP OP_ADD OP_DUP OP_ADD
+        OP_DUP OP_ADD OP_DUP OP_ADD
+        OP_DUP OP_ADD OP_DUP OP_ADD
+        OP_DUP OP_ADD OP_DUP OP_ADD
+    }
+}
+
+pub fn OP_NDUP(n: usize) -> Script {
+    let times_3_dup = if n > 3 { (n - 3) / 3 } else { 0 };
+    let remaining = if n > 3 { (n - 3) % 3 } else { 0 };
+
+    script! {
+
+        if n >= 1 {
+            OP_DUP
+        }
+
+
+        if n >= 3 {
+            OP_2DUP
+        }
+        else if n >= 2{
+            OP_DUP
+        }
+
+
+        for _ in 0..times_3_dup {
+            OP_3DUP
+        }
+
+        if remaining == 2{
+            OP_2DUP
+        }
+        else if remaining == 1{
+            OP_DUP
+        }
+
+    }
+}
+
+pub fn push_to_stack(element: usize, n: usize) -> Script {
+    script! {
+        if n >= 1{
+                {element} {OP_NDUP(n - 1)}
+        }
+    }
+}
+
+pub fn NMUL(n: u32) -> Script {
+    let n_bits = u32::BITS - n.leading_zeros();
+    let bits = (0..n_bits).map(|i| 1 & (n >> i)).collect::<Vec<_>>();
+    script! {
+        if n_bits == 0 { OP_DROP 0 }
+        else {
+            for i in 0..bits.len()-1 {
+                if bits[i] == 1 { OP_DUP }
+                { crate::pseudo::OP_2MUL() }
+            }
+            for _ in 1..bits.iter().sum() { OP_ADD }
+        }
+    }
+}
\ No newline at end of file
diff --git a/splitter/src/test_scripts/mod.rs b/splitter/src/test_scripts/mod.rs
index 26548cf..7eac377 100644
--- a/splitter/src/test_scripts/mod.rs
+++ b/splitter/src/test_scripts/mod.rs
@@ -7,3 +7,4 @@
 
 pub(crate) mod int_add;
 pub(crate) mod int_mul;
+pub(crate) mod sha256;
diff --git a/splitter/src/test_scripts/sha256/mod.rs b/splitter/src/test_scripts/sha256/mod.rs
new file mode 100644
index 0000000..ffa912e
--- /dev/null
+++ b/splitter/src/test_scripts/sha256/mod.rs
@@ -0,0 +1,95 @@
+//! This module contains the test script
+//! for performing the multiplication of two large integers
+//! (exceeding standard Bitcoin 31-bit integers)
+
+use crate::{
+    split::script::{IOPair, SplitableScript},
+    treepp::*,
+};
+use bitcoin_window_mul::{
+    bigint::{U254Windowed, U508},
+    traits::integer::{NonNativeInteger, NonNativeLimbInteger},
+};
+
+use num_bigint::{BigUint, RandomBits};
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha20Rng;
+
+/// Script that performs the addition of two 254-bit numbers
+pub struct U254MulScript;
+
+/// Input size is double the number of limbs of U254 since we are multiplying two numbers
+const INPUT_SIZE: usize = 2 * U254Windowed::N_LIMBS;
+/// Output size is the number of limbs of U508
+const OUTPUT_SIZE: usize = U508::N_LIMBS;
+
+impl SplitableScript<{ INPUT_SIZE }, { OUTPUT_SIZE }> for U254MulScript {
+    fn script() -> Script {
+        U254Windowed::OP_WIDENINGMUL::<U508>()
+    }
+
+    fn generate_valid_io_pair() -> IOPair<{ INPUT_SIZE }, { OUTPUT_SIZE }> {
+        let mut prng = ChaCha20Rng::seed_from_u64(0);
+
+        // Generate two random 254-bit numbers and calculate their sum
+        let num_1: BigUint = prng.sample(RandomBits::new(254));
+        let num_2: BigUint = prng.sample(RandomBits::new(254));
+        let product: BigUint = num_1.clone() * num_2.clone();
+
+        IOPair {
+            input: script! {
+                { U254Windowed::OP_PUSH_U32LESLICE(&num_1.to_u32_digits()) }
+                { U254Windowed::OP_PUSH_U32LESLICE(&num_2.to_u32_digits()) }
+            },
+            output: U508::OP_PUSH_U32LESLICE(&product.to_u32_digits()),
+        }
+    }
+}
+
+// #[cfg(test)]
+// mod tests {
+//     use super::*;
+//     use crate::{bitvm::sha256::sha256, utils::stack_to_script};
+//     use bitcoin_window_mul::traits::comparable::Comparable;
+
+//     #[test]
+//     fn test_sha256() {
+//         println!("sha256(32): {} bytes", sha256(32).len());
+//         println!("sha256(80): {} bytes", sha256(80).len());
+//         println!(
+//             "sha256 chunk: {} bytes",
+//             sha256_transform(8 + 16 + 64 + 1, 8 + 16).len()
+//         );
+//         let hex_in = "6162636462636465636465666465666765666768666768696768696a68696a6b696a6b6c6a6b6c6d6b6c6d6e6c6d6e6f6d6e6f706e6f70716f7071727071727371727374727374757374757674757677";
+//         let mut hasher = Sha256::new();
+//         let data = hex::decode(hex_in).unwrap();
+//         hasher.update(&data);
+//         let mut result = hasher.finalize();
+//         hasher = Sha256::new();
+//         hasher.update(result);
+//         result = hasher.finalize();
+//         let res = hex::encode(result);
+//         let script = script! {
+//             {push_bytes_hex(hex_in)}
+//             {sha256(hex_in.len()/2)}
+//             {sha256(32)}
+//             {push_bytes_hex(res.as_str())}
+//             for _ in 0..32 {
+//                 OP_TOALTSTACK
+//             }
+
+//             for i in 1..32 {
+//                 {i}
+//                 OP_ROLL
+//             }
+
+//             for _ in 0..32 {
+//                 OP_FROMALTSTACK
+//                 OP_EQUALVERIFY
+//             }
+//             OP_TRUE
+//         };
+//         let res = execute_script(script);
+//         assert!(res.success);
+//     }
+// }

From abec917bb5fda45d4171139243e613a6fee2f771 Mon Sep 17 00:00:00 2001
From: ZamDimon <zamdmytro@gmail.com>
Date: Thu, 19 Sep 2024 21:49:58 +0300
Subject: [PATCH 15/17] :construction: wip, add more sha256-related material

---
 splitter/src/bitvm/hash/mod.rs          |   2 +-
 splitter/src/bitvm/hash/sha256.rs       |  72 ++++++++++--
 splitter/src/bitvm/hash/utils.rs        |   2 +-
 splitter/src/bitvm/mod.rs               |   2 +-
 splitter/src/bitvm/u32/mod.rs           |   4 +-
 splitter/src/bitvm/u32/u32_add.rs       |  11 +-
 splitter/src/bitvm/u32/u32_and.rs       |  12 +-
 splitter/src/bitvm/u32/u32_rrot.rs      |   6 +-
 splitter/src/bitvm/u32/u32_std.rs       |   4 +-
 splitter/src/bitvm/u32/u32_xor.rs       |  12 +-
 splitter/src/bitvm/u32/u32_zip.rs       |   2 +-
 splitter/src/debug.rs                   |   3 +-
 splitter/src/pseudo.rs                  |   2 +-
 splitter/src/split/core.rs              |   2 +-
 splitter/src/test_scripts/sha256.rs     | 146 ++++++++++++++++++++++++
 splitter/src/test_scripts/sha256/mod.rs |  95 ---------------
 16 files changed, 241 insertions(+), 136 deletions(-)
 create mode 100644 splitter/src/test_scripts/sha256.rs
 delete mode 100644 splitter/src/test_scripts/sha256/mod.rs

diff --git a/splitter/src/bitvm/hash/mod.rs b/splitter/src/bitvm/hash/mod.rs
index 7c33308..c31de2d 100644
--- a/splitter/src/bitvm/hash/mod.rs
+++ b/splitter/src/bitvm/hash/mod.rs
@@ -1,2 +1,2 @@
 pub mod sha256;
-pub mod utils;
\ No newline at end of file
+pub mod utils;
diff --git a/splitter/src/bitvm/hash/sha256.rs b/splitter/src/bitvm/hash/sha256.rs
index 3a27dc0..b1232b9 100644
--- a/splitter/src/bitvm/hash/sha256.rs
+++ b/splitter/src/bitvm/hash/sha256.rs
@@ -1,7 +1,5 @@
 #![allow(non_snake_case)]
 
-use crate::pseudo::push_to_stack;
-use crate::treepp::*;
 use crate::bitvm::u32::u32_add::u32_add_drop;
 use crate::bitvm::u32::u32_std::{u32_dup, u32_roll};
 use crate::bitvm::u32::{
@@ -10,6 +8,8 @@ use crate::bitvm::u32::{
     u32_std::{u32_drop, u32_fromaltstack, u32_pick, u32_push, u32_toaltstack},
     u32_xor::{u32_xor, u8_drop_xor_table, u8_push_xor_table},
 };
+use crate::pseudo::push_to_stack;
+use crate::treepp::*;
 
 const K: [u32; 64] = [
     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
@@ -130,12 +130,12 @@ pub fn sha256_80bytes() -> Script {
 /// reorder bytes for u32
 pub fn padding_add_roll(num_bytes: usize) -> Script {
     assert!(num_bytes < 512);
-    let padding_num;
-    if (num_bytes % 64) < 56 {
-        padding_num = 55 - (num_bytes % 64);
+
+    let padding_num = if (num_bytes % 64) < 56 {
+        55 - (num_bytes % 64)
     } else {
-        padding_num = 64 + 55 - (num_bytes % 64);
-    }
+        64 + 55 - (num_bytes % 64)
+    };
 
     let u32_num = (num_bytes + padding_num + 9) / 4;
     script! {
@@ -914,10 +914,10 @@ pub fn maj(x: u32, y: u32, z: u32, stack_depth: u32) -> Script {
 
 #[cfg(test)]
 mod tests {
-    use crate::bitvm::hash::utils::push_bytes_hex;
     use crate::bitvm::hash::sha256::*;
-    use crate::treepp::*;
+    use crate::bitvm::hash::utils::push_bytes_hex;
     use crate::bitvm::u32::u32_std::{u32_equal, u32_equalverify};
+    use rand::RngCore;
     use sha2::{Digest, Sha256};
 
     fn rrot(x: u32, n: usize) -> u32 {
@@ -968,6 +968,55 @@ mod tests {
         assert!(res.success);
     }
 
+    #[test]
+    fn test_random_sha256() {
+        // Number of bytes for a random array
+        const BYTES_NUMBER: usize = 80;
+
+        // Generate a random array of bytes
+        let mut data = [0; BYTES_NUMBER];
+        rand::thread_rng().fill_bytes(&mut data);
+        let data_hex = hex::encode(&data);
+
+        // Creating a SHA-256 hasher
+        let mut hasher = Sha256::new();
+        hasher.update(&data);
+        let mut result = hasher.finalize();
+
+        // Now, doing the same thing again, but for the current digest
+        hasher = Sha256::new();
+        hasher.update(result);
+        result = hasher.finalize();
+        let result = hex::encode(result);
+
+        let script = script! {
+            { push_bytes_hex(data_hex.as_str()) }
+            { sha256(BYTES_NUMBER) }
+            { sha256(32) }
+
+            { push_bytes_hex(result.as_str()) }
+
+            for _ in 0..32 {
+                OP_TOALTSTACK
+            }
+
+            for i in 1..32 {
+                {i}
+                OP_ROLL
+            }
+
+            for _ in 0..32 {
+                OP_FROMALTSTACK
+                OP_EQUALVERIFY
+            }
+
+            OP_TRUE
+        };
+
+        let exec_result = execute_script(script);
+        assert!(exec_result.success, "Execution failed: {}", exec_result);
+    }
+
     #[test]
     fn test_padding_add_roll() {
         let hex_in = "6162636462636465636465666465666765666768666768696768696a68696a6b696a6b6c6a6b6c6d6b6c6d6e6c6d6e6f6d6e6f706e6f7071";
@@ -991,9 +1040,8 @@ mod tests {
                 {u32_equalverify()} //
             }
         };
+
         execute_script(script);
-        // assert!(res.success);
-        // println!("result {:100}", res);
     }
 
     #[test]
@@ -1163,4 +1211,4 @@ mod tests {
         let res = execute_script(script);
         assert!(res.success);
     }
-}
\ No newline at end of file
+}
diff --git a/splitter/src/bitvm/hash/utils.rs b/splitter/src/bitvm/hash/utils.rs
index 67d9296..367531d 100644
--- a/splitter/src/bitvm/hash/utils.rs
+++ b/splitter/src/bitvm/hash/utils.rs
@@ -16,4 +16,4 @@ pub fn push_bytes_hex(hex: &str) -> Script {
             { *byte }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/splitter/src/bitvm/mod.rs b/splitter/src/bitvm/mod.rs
index 13fb514..bd7f225 100644
--- a/splitter/src/bitvm/mod.rs
+++ b/splitter/src/bitvm/mod.rs
@@ -1,5 +1,5 @@
 //! Package that contains the implementation of certain test
 //! scripts from BitVM2 that are used to test the functionality of the splitter.
 
+pub(crate) mod hash;
 pub(crate) mod u32;
-pub(crate) mod hash;
\ No newline at end of file
diff --git a/splitter/src/bitvm/u32/mod.rs b/splitter/src/bitvm/u32/mod.rs
index afa2667..e1ba7b6 100644
--- a/splitter/src/bitvm/u32/mod.rs
+++ b/splitter/src/bitvm/u32/mod.rs
@@ -1,6 +1,6 @@
 pub mod u32_add;
 pub mod u32_and;
+pub mod u32_rrot;
 pub mod u32_std;
 pub mod u32_xor;
-pub mod u32_rrot;
-pub mod u32_zip;
\ No newline at end of file
+pub mod u32_zip;
diff --git a/splitter/src/bitvm/u32/u32_add.rs b/splitter/src/bitvm/u32/u32_add.rs
index b0730fc..cbfb7f1 100644
--- a/splitter/src/bitvm/u32/u32_add.rs
+++ b/splitter/src/bitvm/u32/u32_add.rs
@@ -1,5 +1,5 @@
-use crate::treepp::*;
 use crate::bitvm::u32::u32_zip::{u32_copy_zip, u32_zip};
+use crate::treepp::*;
 
 pub fn u8_add_carry() -> Script {
     script! {
@@ -32,6 +32,7 @@ pub fn u8_add() -> Script {
 
 /// Addition of two u32 values represented as u8
 /// Copies the first summand `a` and drops `b`
+#[allow(dead_code)]
 pub fn u32_add(a: u32, b: u32) -> Script {
     assert_ne!(a, b);
     script! {
@@ -104,10 +105,10 @@ pub fn u32_add_drop(a: u32, b: u32) -> Script {
 
 #[cfg(test)]
 mod test {
-    use crate::debug::run_and_assert;
-    use crate::treepp::script;
     use crate::bitvm::u32::u32_add::*;
     use crate::bitvm::u32::u32_std::u32_push;
+    use crate::debug::run_and_assert;
+    use crate::treepp::script;
 
     #[test]
     fn test_u32_add() {
@@ -123,7 +124,7 @@ mod test {
             0xee OP_EQUALVERIFY
             0xee OP_EQUAL
         };
-        
+
         run_and_assert(script);
     }
-}
\ No newline at end of file
+}
diff --git a/splitter/src/bitvm/u32/u32_and.rs b/splitter/src/bitvm/u32/u32_and.rs
index c0c7a26..1aaa4f0 100644
--- a/splitter/src/bitvm/u32/u32_and.rs
+++ b/splitter/src/bitvm/u32/u32_and.rs
@@ -1,7 +1,7 @@
 #![allow(dead_code)]
 
-use crate::treepp::*;
 use crate::bitvm::u32::u32_zip::u32_copy_zip;
+use crate::treepp::*;
 
 /// The bitwise AND of two u8 elements.
 /// Expects the u8_xor_table to be on the stack
@@ -98,14 +98,16 @@ pub fn u32_and(a: u32, b: u32, stack_size: u32) -> Script {
 #[cfg(test)]
 mod tests {
 
-    use crate::debug::run_and_assert;
-    use crate::treepp::script;
     use crate::bitvm::u32::u32_and::*;
     use crate::bitvm::u32::u32_std::*;
     use crate::bitvm::u32::u32_xor::{u8_drop_xor_table, u8_push_xor_table};
+    use crate::debug::run_and_assert;
+    use crate::treepp::script;
     use rand::Rng;
 
-    fn and(x: u32, y: u32) -> u32 { x & y }
+    fn and(x: u32, y: u32) -> u32 {
+        x & y
+    }
 
     #[test]
     fn test_and() {
@@ -129,4 +131,4 @@ mod tests {
             run_and_assert(exec_script);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/splitter/src/bitvm/u32/u32_rrot.rs b/splitter/src/bitvm/u32/u32_rrot.rs
index 3ec7afe..05d2406 100644
--- a/splitter/src/bitvm/u32/u32_rrot.rs
+++ b/splitter/src/bitvm/u32/u32_rrot.rs
@@ -223,10 +223,10 @@ pub fn u32_rrot(rot_num: usize) -> Script {
 #[cfg(test)]
 mod tests {
 
-    use crate::debug::run_and_assert;
-    use crate::treepp::script;
     use crate::bitvm::u32::u32_rrot::*;
     use crate::bitvm::u32::u32_std::*;
+    use crate::debug::run_and_assert;
+    use crate::treepp::script;
     use rand::Rng;
 
     fn rrot(x: u32, n: usize) -> u32 {
@@ -255,4 +255,4 @@ mod tests {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/splitter/src/bitvm/u32/u32_std.rs b/splitter/src/bitvm/u32/u32_std.rs
index d50ea1b..6897c2e 100644
--- a/splitter/src/bitvm/u32/u32_std.rs
+++ b/splitter/src/bitvm/u32/u32_std.rs
@@ -162,9 +162,9 @@ pub fn u32_compress() -> Script {
 
 #[cfg(test)]
 mod test {
+    use crate::bitvm::u32::u32_std::*;
     use crate::debug::run_and_assert;
     use crate::treepp::script;
-    use crate::bitvm::u32::u32_std::*;
     use rand::Rng;
 
     #[test]
@@ -211,4 +211,4 @@ mod test {
             run_and_assert(script);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/splitter/src/bitvm/u32/u32_xor.rs b/splitter/src/bitvm/u32/u32_xor.rs
index 87e1b07..2c11512 100644
--- a/splitter/src/bitvm/u32/u32_xor.rs
+++ b/splitter/src/bitvm/u32/u32_xor.rs
@@ -1,7 +1,7 @@
 #![allow(dead_code)]
 
-use crate::treepp::*;
 use crate::bitvm::u32::u32_zip::u32_copy_zip;
+use crate::treepp::*;
 
 /// Bitwise XOR of two u8 elements
 ///
@@ -339,13 +339,15 @@ pub fn u8_drop_xor_table() -> Script {
 #[cfg(test)]
 mod tests {
 
-    use crate::debug::run_and_assert;
-    use crate::treepp::*;
     use crate::bitvm::u32::u32_std::*;
     use crate::bitvm::u32::u32_xor::{u32_xor, u8_drop_xor_table, u8_push_xor_table};
+    use crate::debug::run_and_assert;
+    use crate::treepp::*;
     use rand::Rng;
 
-    fn xor(x: u32, y: u32) -> u32 { x ^ y }
+    fn xor(x: u32, y: u32) -> u32 {
+        x ^ y
+    }
 
     #[test]
     fn test_xor() {
@@ -370,4 +372,4 @@ mod tests {
             run_and_assert(script);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/splitter/src/bitvm/u32/u32_zip.rs b/splitter/src/bitvm/u32/u32_zip.rs
index 289e41f..82cbe0b 100644
--- a/splitter/src/bitvm/u32/u32_zip.rs
+++ b/splitter/src/bitvm/u32/u32_zip.rs
@@ -56,4 +56,4 @@ pub fn _u32_zip_copy(mut a: u32, mut b: u32) -> Script {
         {a+2} OP_ROLL {b} OP_PICK
         {a+3} OP_ROLL {b} OP_PICK
     }
-}
\ No newline at end of file
+}
diff --git a/splitter/src/debug.rs b/splitter/src/debug.rs
index 23872a5..c4d1cf7 100644
--- a/splitter/src/debug.rs
+++ b/splitter/src/debug.rs
@@ -1,7 +1,7 @@
+use crate::treepp;
 use bitcoin::{hashes::Hash, ScriptBuf, TapLeafHash, Transaction};
 use bitcoin_scriptexec::{Exec, ExecCtx, ExecError, ExecStats, Options, Stack, TxTemplate};
 use core::fmt;
-use crate::treepp;
 
 /// Information about the status of the script execution.
 #[derive(Debug)]
@@ -128,6 +128,7 @@ pub fn execute_script_no_stack_limit(script: bitcoin::ScriptBuf) -> ExecuteInfo
 }
 
 /// Run the given script and panic if the script execution fails.
+#[allow(dead_code)]
 pub fn run_and_assert(script: treepp::Script) {
     let exec_result = execute_script(script);
     if !exec_result.success {
diff --git a/splitter/src/pseudo.rs b/splitter/src/pseudo.rs
index f71ad08..e5e8926 100644
--- a/splitter/src/pseudo.rs
+++ b/splitter/src/pseudo.rs
@@ -166,4 +166,4 @@ pub fn NMUL(n: u32) -> Script {
             for _ in 1..bits.iter().sum() { OP_ADD }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/splitter/src/split/core.rs b/splitter/src/split/core.rs
index 686ee82..f2bacb2 100644
--- a/splitter/src/split/core.rs
+++ b/splitter/src/split/core.rs
@@ -6,7 +6,7 @@ use super::script::SplitResult;
 use crate::{split::intermediate_state::IntermediateState, treepp::*};
 
 /// Maximum size of the script in bytes
-pub(super) const MAX_SCRIPT_SIZE: usize = 30000;
+pub(super) const MAX_SCRIPT_SIZE: usize = 18000;
 
 // TODO: Currently, the chunk size splits the script into the parts of the same size IN TERMS OF INSTRUCTIONS, not bytes.
 /// Splits the given script into smaller parts
diff --git a/splitter/src/test_scripts/sha256.rs b/splitter/src/test_scripts/sha256.rs
new file mode 100644
index 0000000..5161d5c
--- /dev/null
+++ b/splitter/src/test_scripts/sha256.rs
@@ -0,0 +1,146 @@
+//! This module contains the test script
+//! for performing the multiplication of two large integers
+//! (exceeding standard Bitcoin 31-bit integers)
+
+use crate::{
+    bitvm::hash::{sha256::sha256, utils::push_bytes_hex},
+    split::script::{IOPair, SplitableScript},
+    treepp::*,
+};
+
+use rand::RngCore;
+use sha2::{Digest, Sha256};
+
+/// Script that performs the addition of two 254-bit numbers
+pub struct SHA256Script<const INPUT_SIZE: usize>;
+
+/// Output size is 32 bytes (256 bits)
+const OUTPUT_SIZE: usize = 32;
+
+impl<const INPUT_SIZE: usize> SplitableScript<INPUT_SIZE, { OUTPUT_SIZE }>
+    for SHA256Script<INPUT_SIZE>
+{
+    fn script() -> Script {
+        sha256(INPUT_SIZE)
+    }
+
+    fn generate_valid_io_pair() -> IOPair<INPUT_SIZE, { OUTPUT_SIZE }> {
+        // Generate a random array of bytes
+        let mut data = [0; INPUT_SIZE];
+        rand::thread_rng().fill_bytes(&mut data);
+        let data_hex = hex::encode(data);
+
+        // Creating a SHA-256 hasher and find digest of the data
+        let mut hasher = Sha256::new();
+        hasher.update(data);
+        let result = hasher.finalize();
+
+        IOPair {
+            input: script! {
+                { push_bytes_hex(data_hex.as_str()) }
+            },
+            output: script! {
+                { push_bytes_hex(hex::encode(result).as_str()) }
+            },
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::utils::stack_to_script;
+
+    use super::*;
+
+    #[test]
+    fn test_sha256_verify() {
+        const TEST_BYTES_NUM: usize = 80;
+        assert!(SHA256Script::<TEST_BYTES_NUM>::verify_random());
+    }
+
+    #[test]
+    fn test_naive_split_correctness() {
+        // Choosing the number of bytes for the test
+        const TEST_BYTES_NUM: usize = 80;
+        type SHA256ScriptType = SHA256Script<TEST_BYTES_NUM>;
+
+        // Generating a random valid input for the script and the script itself
+        let IOPair { input, output } = SHA256ScriptType::generate_valid_io_pair();
+        assert!(
+            SHA256ScriptType::verify(input.clone(), output.clone()),
+            "input/output is not correct"
+        );
+
+        // Splitting the script into shards
+        let split_result = SHA256ScriptType::split(input.clone());
+
+        // Now, we are going to concatenate all the shards and verify that the script is also correct
+        let verification_script = script! {
+            { input }
+            for shard in split_result.shards {
+                { shard }
+            }
+            { output }
+
+            // Now, we need to verify that the output is correct.
+            for i in (0..SHA256ScriptType::OUTPUT_SIZE).rev() {
+                // { <a_1> <a_2> ... <a_n> <b_1> <b_2> ... <b_n> } <- we need to push element <a_n> to the top of the stack
+                { i+1 } OP_ROLL
+                OP_EQUALVERIFY
+            }
+
+            OP_TRUE
+        };
+
+        let result = execute_script(verification_script);
+        assert!(result.success, "Verification has failed");
+    }
+
+    #[test]
+    fn test_naive_split() {
+        // Choosing the number of bytes for the test
+        const TEST_BYTES_NUM: usize = 80;
+        type SHA256ScriptType = SHA256Script<TEST_BYTES_NUM>;
+
+        // First, we generate the pair of input and output scripts
+        let IOPair { input, output } = SHA256ScriptType::generate_valid_io_pair();
+
+        // Splitting the script into shards
+        let split_result = SHA256ScriptType::split(input);
+
+        // Checking the last state (which must be equal to the result of the multiplication)
+        let last_state = split_result.must_last_state();
+
+        // Altstack must be empty
+        assert!(last_state.altstack.is_empty(), "altstack is not empty!");
+
+        println!(
+            "Last state: {:?}",
+            stack_to_script(&last_state.stack).to_asm_string()
+        );
+        println!("Output: {:?}", output.to_asm_string());
+
+        // The element of the mainstack must be equal to the actual output
+        let verification_script = script! {
+            { stack_to_script(&last_state.stack) }
+            { output }
+
+            // Now, we need to verify that the output is correct.
+            // We have 32 bytes in the output, so we need to compare each byte
+            for i in (0..SHA256ScriptType::OUTPUT_SIZE).rev() {
+                { i+1 } OP_ROLL
+                OP_EQUALVERIFY
+            }
+
+            // Marking the verification as successful
+            OP_TRUE
+        };
+
+        let result = execute_script(verification_script);
+        assert!(result.success, "verification has failed");
+
+        // Now, we debug the total size of the states
+        let total_size = split_result.total_states_size();
+        println!("Total size of the states: {} bytes", total_size);
+    }
+}
diff --git a/splitter/src/test_scripts/sha256/mod.rs b/splitter/src/test_scripts/sha256/mod.rs
deleted file mode 100644
index ffa912e..0000000
--- a/splitter/src/test_scripts/sha256/mod.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-//! This module contains the test script
-//! for performing the multiplication of two large integers
-//! (exceeding standard Bitcoin 31-bit integers)
-
-use crate::{
-    split::script::{IOPair, SplitableScript},
-    treepp::*,
-};
-use bitcoin_window_mul::{
-    bigint::{U254Windowed, U508},
-    traits::integer::{NonNativeInteger, NonNativeLimbInteger},
-};
-
-use num_bigint::{BigUint, RandomBits};
-use rand::{Rng, SeedableRng};
-use rand_chacha::ChaCha20Rng;
-
-/// Script that performs the addition of two 254-bit numbers
-pub struct U254MulScript;
-
-/// Input size is double the number of limbs of U254 since we are multiplying two numbers
-const INPUT_SIZE: usize = 2 * U254Windowed::N_LIMBS;
-/// Output size is the number of limbs of U508
-const OUTPUT_SIZE: usize = U508::N_LIMBS;
-
-impl SplitableScript<{ INPUT_SIZE }, { OUTPUT_SIZE }> for U254MulScript {
-    fn script() -> Script {
-        U254Windowed::OP_WIDENINGMUL::<U508>()
-    }
-
-    fn generate_valid_io_pair() -> IOPair<{ INPUT_SIZE }, { OUTPUT_SIZE }> {
-        let mut prng = ChaCha20Rng::seed_from_u64(0);
-
-        // Generate two random 254-bit numbers and calculate their sum
-        let num_1: BigUint = prng.sample(RandomBits::new(254));
-        let num_2: BigUint = prng.sample(RandomBits::new(254));
-        let product: BigUint = num_1.clone() * num_2.clone();
-
-        IOPair {
-            input: script! {
-                { U254Windowed::OP_PUSH_U32LESLICE(&num_1.to_u32_digits()) }
-                { U254Windowed::OP_PUSH_U32LESLICE(&num_2.to_u32_digits()) }
-            },
-            output: U508::OP_PUSH_U32LESLICE(&product.to_u32_digits()),
-        }
-    }
-}
-
-// #[cfg(test)]
-// mod tests {
-//     use super::*;
-//     use crate::{bitvm::sha256::sha256, utils::stack_to_script};
-//     use bitcoin_window_mul::traits::comparable::Comparable;
-
-//     #[test]
-//     fn test_sha256() {
-//         println!("sha256(32): {} bytes", sha256(32).len());
-//         println!("sha256(80): {} bytes", sha256(80).len());
-//         println!(
-//             "sha256 chunk: {} bytes",
-//             sha256_transform(8 + 16 + 64 + 1, 8 + 16).len()
-//         );
-//         let hex_in = "6162636462636465636465666465666765666768666768696768696a68696a6b696a6b6c6a6b6c6d6b6c6d6e6c6d6e6f6d6e6f706e6f70716f7071727071727371727374727374757374757674757677";
-//         let mut hasher = Sha256::new();
-//         let data = hex::decode(hex_in).unwrap();
-//         hasher.update(&data);
-//         let mut result = hasher.finalize();
-//         hasher = Sha256::new();
-//         hasher.update(result);
-//         result = hasher.finalize();
-//         let res = hex::encode(result);
-//         let script = script! {
-//             {push_bytes_hex(hex_in)}
-//             {sha256(hex_in.len()/2)}
-//             {sha256(32)}
-//             {push_bytes_hex(res.as_str())}
-//             for _ in 0..32 {
-//                 OP_TOALTSTACK
-//             }
-
-//             for i in 1..32 {
-//                 {i}
-//                 OP_ROLL
-//             }
-
-//             for _ in 0..32 {
-//                 OP_FROMALTSTACK
-//                 OP_EQUALVERIFY
-//             }
-//             OP_TRUE
-//         };
-//         let res = execute_script(script);
-//         assert!(res.success);
-//     }
-// }

From 05f0a2b62edf25659e1d795a0c450df03d946687 Mon Sep 17 00:00:00 2001
From: ZamDimon <zamdmytro@gmail.com>
Date: Mon, 30 Sep 2024 19:57:16 +0300
Subject: [PATCH 16/17] :truck: :recycle: finish basic splitter

---
 Cargo.toml                                    |   2 +-
 {splitter => bitcoin-splitter}/Cargo.toml     |   2 +-
 {splitter => bitcoin-splitter}/README.md      |   0
 .../src/bitvm/hash/mod.rs                     |   0
 .../src/bitvm/hash/sha256.rs                  |   0
 .../src/bitvm/hash/utils.rs                   |   0
 .../src/bitvm/mod.rs                          |   0
 .../src/bitvm/u32/mod.rs                      |   0
 .../src/bitvm/u32/u32_add.rs                  |   0
 .../src/bitvm/u32/u32_and.rs                  |   0
 .../src/bitvm/u32/u32_rrot.rs                 |   0
 .../src/bitvm/u32/u32_std.rs                  |   0
 .../src/bitvm/u32/u32_xor.rs                  |   0
 .../src/bitvm/u32/u32_zip.rs                  |   0
 {splitter => bitcoin-splitter}/src/debug.rs   |   0
 {splitter => bitcoin-splitter}/src/lib.rs     |   0
 {splitter => bitcoin-splitter}/src/pseudo.rs  |   0
 bitcoin-splitter/src/split/core.rs            | 127 ++++++++++++++++++
 .../src/split/intermediate_state.rs           |   0
 .../src/split/mod.rs                          |   0
 .../src/split/script.rs                       |  31 ++++-
 .../src/split/tests.rs                        |  50 ++++++-
 .../src/test_scripts/int_add.rs               |   6 +-
 .../src/test_scripts/int_mul.rs               |   9 +-
 .../src/test_scripts/mod.rs                   |   0
 .../src/test_scripts/sha256.rs                |   7 +-
 {splitter => bitcoin-splitter}/src/utils.rs   |   0
 splitter/src/split/core.rs                    |  67 ---------
 28 files changed, 214 insertions(+), 87 deletions(-)
 rename {splitter => bitcoin-splitter}/Cargo.toml (97%)
 rename {splitter => bitcoin-splitter}/README.md (100%)
 rename {splitter => bitcoin-splitter}/src/bitvm/hash/mod.rs (100%)
 rename {splitter => bitcoin-splitter}/src/bitvm/hash/sha256.rs (100%)
 rename {splitter => bitcoin-splitter}/src/bitvm/hash/utils.rs (100%)
 rename {splitter => bitcoin-splitter}/src/bitvm/mod.rs (100%)
 rename {splitter => bitcoin-splitter}/src/bitvm/u32/mod.rs (100%)
 rename {splitter => bitcoin-splitter}/src/bitvm/u32/u32_add.rs (100%)
 rename {splitter => bitcoin-splitter}/src/bitvm/u32/u32_and.rs (100%)
 rename {splitter => bitcoin-splitter}/src/bitvm/u32/u32_rrot.rs (100%)
 rename {splitter => bitcoin-splitter}/src/bitvm/u32/u32_std.rs (100%)
 rename {splitter => bitcoin-splitter}/src/bitvm/u32/u32_xor.rs (100%)
 rename {splitter => bitcoin-splitter}/src/bitvm/u32/u32_zip.rs (100%)
 rename {splitter => bitcoin-splitter}/src/debug.rs (100%)
 rename {splitter => bitcoin-splitter}/src/lib.rs (100%)
 rename {splitter => bitcoin-splitter}/src/pseudo.rs (100%)
 create mode 100644 bitcoin-splitter/src/split/core.rs
 rename {splitter => bitcoin-splitter}/src/split/intermediate_state.rs (100%)
 rename {splitter => bitcoin-splitter}/src/split/mod.rs (100%)
 rename {splitter => bitcoin-splitter}/src/split/script.rs (77%)
 rename {splitter => bitcoin-splitter}/src/split/tests.rs (86%)
 rename {splitter => bitcoin-splitter}/src/test_scripts/int_add.rs (94%)
 rename {splitter => bitcoin-splitter}/src/test_scripts/int_mul.rs (92%)
 rename {splitter => bitcoin-splitter}/src/test_scripts/mod.rs (100%)
 rename {splitter => bitcoin-splitter}/src/test_scripts/sha256.rs (95%)
 rename {splitter => bitcoin-splitter}/src/utils.rs (100%)
 delete mode 100644 splitter/src/split/core.rs

diff --git a/Cargo.toml b/Cargo.toml
index aec6998..b584f8e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,5 @@
 [workspace]
-members = ["splitter"]
+members = ["bitcoin-splitter"]
 resolver = "2"
 
 [profile.dev]
diff --git a/splitter/Cargo.toml b/bitcoin-splitter/Cargo.toml
similarity index 97%
rename from splitter/Cargo.toml
rename to bitcoin-splitter/Cargo.toml
index a8b9eec..d6a80db 100644
--- a/splitter/Cargo.toml
+++ b/bitcoin-splitter/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name    = "bitvm2-splitter"
+name    = "bitcoin-splitter"
 version = "0.1.0"
 edition = "2021"
 
diff --git a/splitter/README.md b/bitcoin-splitter/README.md
similarity index 100%
rename from splitter/README.md
rename to bitcoin-splitter/README.md
diff --git a/splitter/src/bitvm/hash/mod.rs b/bitcoin-splitter/src/bitvm/hash/mod.rs
similarity index 100%
rename from splitter/src/bitvm/hash/mod.rs
rename to bitcoin-splitter/src/bitvm/hash/mod.rs
diff --git a/splitter/src/bitvm/hash/sha256.rs b/bitcoin-splitter/src/bitvm/hash/sha256.rs
similarity index 100%
rename from splitter/src/bitvm/hash/sha256.rs
rename to bitcoin-splitter/src/bitvm/hash/sha256.rs
diff --git a/splitter/src/bitvm/hash/utils.rs b/bitcoin-splitter/src/bitvm/hash/utils.rs
similarity index 100%
rename from splitter/src/bitvm/hash/utils.rs
rename to bitcoin-splitter/src/bitvm/hash/utils.rs
diff --git a/splitter/src/bitvm/mod.rs b/bitcoin-splitter/src/bitvm/mod.rs
similarity index 100%
rename from splitter/src/bitvm/mod.rs
rename to bitcoin-splitter/src/bitvm/mod.rs
diff --git a/splitter/src/bitvm/u32/mod.rs b/bitcoin-splitter/src/bitvm/u32/mod.rs
similarity index 100%
rename from splitter/src/bitvm/u32/mod.rs
rename to bitcoin-splitter/src/bitvm/u32/mod.rs
diff --git a/splitter/src/bitvm/u32/u32_add.rs b/bitcoin-splitter/src/bitvm/u32/u32_add.rs
similarity index 100%
rename from splitter/src/bitvm/u32/u32_add.rs
rename to bitcoin-splitter/src/bitvm/u32/u32_add.rs
diff --git a/splitter/src/bitvm/u32/u32_and.rs b/bitcoin-splitter/src/bitvm/u32/u32_and.rs
similarity index 100%
rename from splitter/src/bitvm/u32/u32_and.rs
rename to bitcoin-splitter/src/bitvm/u32/u32_and.rs
diff --git a/splitter/src/bitvm/u32/u32_rrot.rs b/bitcoin-splitter/src/bitvm/u32/u32_rrot.rs
similarity index 100%
rename from splitter/src/bitvm/u32/u32_rrot.rs
rename to bitcoin-splitter/src/bitvm/u32/u32_rrot.rs
diff --git a/splitter/src/bitvm/u32/u32_std.rs b/bitcoin-splitter/src/bitvm/u32/u32_std.rs
similarity index 100%
rename from splitter/src/bitvm/u32/u32_std.rs
rename to bitcoin-splitter/src/bitvm/u32/u32_std.rs
diff --git a/splitter/src/bitvm/u32/u32_xor.rs b/bitcoin-splitter/src/bitvm/u32/u32_xor.rs
similarity index 100%
rename from splitter/src/bitvm/u32/u32_xor.rs
rename to bitcoin-splitter/src/bitvm/u32/u32_xor.rs
diff --git a/splitter/src/bitvm/u32/u32_zip.rs b/bitcoin-splitter/src/bitvm/u32/u32_zip.rs
similarity index 100%
rename from splitter/src/bitvm/u32/u32_zip.rs
rename to bitcoin-splitter/src/bitvm/u32/u32_zip.rs
diff --git a/splitter/src/debug.rs b/bitcoin-splitter/src/debug.rs
similarity index 100%
rename from splitter/src/debug.rs
rename to bitcoin-splitter/src/debug.rs
diff --git a/splitter/src/lib.rs b/bitcoin-splitter/src/lib.rs
similarity index 100%
rename from splitter/src/lib.rs
rename to bitcoin-splitter/src/lib.rs
diff --git a/splitter/src/pseudo.rs b/bitcoin-splitter/src/pseudo.rs
similarity index 100%
rename from splitter/src/pseudo.rs
rename to bitcoin-splitter/src/pseudo.rs
diff --git a/bitcoin-splitter/src/split/core.rs b/bitcoin-splitter/src/split/core.rs
new file mode 100644
index 0000000..f8a4d5e
--- /dev/null
+++ b/bitcoin-splitter/src/split/core.rs
@@ -0,0 +1,127 @@
+//! Module containing the logic of splitting the script into smaller parts
+
+use bitcoin::{
+    opcodes::all::{OP_ENDIF, OP_IF},
+    script::Instruction,
+};
+
+use super::script::SplitResult;
+use crate::{split::intermediate_state::IntermediateState, treepp::*};
+
+/// Optimal size of the script in bytes
+///
+/// Note that it is not possible to cut the script into ideal
+/// pieces of the same size, so we need to find the optimal size
+/// that will be used to split the script and the algorithm
+/// will try to keep the size of the script as close to the optimal
+/// as possible.
+pub(super) const OPTIMAL_SCRIPT_SIZE: usize = 20000;
+
+/// Maximum scriptsize in bytes that is allowed by the Bitcoin network
+pub(super) const MAX_SCRIPT_SIZE: usize = 50000;
+
+/// Type of the split that we are going to use
+///
+/// - [`SplitType::ByInstructions`]- splits the script by the number of instructions
+/// - [`SplitType::ByBytes`] - splits the script by the number of bytes
+pub enum SplitType {
+    ByInstructions,
+    ByBytes,
+}
+
+// TODO: Currently, the chunk size splits the script into the parts of the same size IN TERMS OF INSTRUCTIONS, not bytes.
+/// Splits the given script into smaller parts
+pub(super) fn split_into_shards(
+    script: &Script,
+    chunk_size: usize,
+    split_type: SplitType,
+) -> Vec<Script> {
+    let instructions: Vec<Instruction> = script
+        .instructions()
+        .map(|instruction| instruction.expect("script is most likely corrupted"))
+        .collect();
+
+    // Now, we are going to collect the chunks
+    let mut shards: Vec<Script> = vec![Script::new()];
+
+    // Now, one of the biggest problems that can occur is that OP_IF and OP_ENDIF are not in the same shard.
+    // For that reason, we count both of them and if the number of OP_IFs is not equal to the number of OP_ENDIFs,
+    // we need to continue splitting the script until we have the same number of both.
+    let mut if_count = 0;
+    let mut endif_count = 0;
+
+    for (instruction_id, instruction) in instructions.clone().into_iter().enumerate() {
+        // Pushing the instruction to the current shard.
+        let current_shard = shards.last_mut().expect("shards should not be empty");
+        current_shard.push_instruction(instruction);
+
+        let current_shard_size = match split_type {
+            SplitType::ByInstructions => instruction_id % chunk_size + 1,
+            SplitType::ByBytes => current_shard.len(),
+        };
+
+        // Checking if the current instruction is OP_IF or OP_ENDIF
+        if let Instruction::Op(op) = instruction {
+            match op {
+                OP_IF => {
+                    if_count += 1;
+                }
+                OP_ENDIF => {
+                    endif_count += 1;
+                }
+                _ => {}
+            }
+        }
+
+        // If the current shard is too big AND number of ifs and endifs
+        // is the same, we need to create a new one
+        if current_shard_size >= chunk_size && if_count == endif_count {
+            shards.push(Script::new());
+        }
+
+        // Checking that the total size has not exceeded the maximum size
+        assert!(
+            current_shard_size <= MAX_SCRIPT_SIZE,
+            "Script size has exceeded the maximum size"
+        );
+    }
+
+    shards
+}
+
+pub(super) fn naive_split(input: Script, script: Script, split_type: SplitType) -> SplitResult {
+    // First, we split the script into smaller parts
+    let shards = split_into_shards(&script, OPTIMAL_SCRIPT_SIZE, split_type);
+    let mut intermediate_states: Vec<IntermediateState> = vec![];
+
+    // Then, we do the following steps:
+    // 1. We execute the first script with the input
+    // 2. We take the stack and write it to the intermediate results
+    // 3. We execute the second script with the saved intermediate results
+    // 4. Take the stask, save to the intermediate results
+    // 5. Repeat until the last script
+
+    intermediate_states.push(IntermediateState::from_input_script(&input, &shards[0]));
+
+    for shard in shards.clone().into_iter().skip(1) {
+        // Executing a piece of the script with the current input.
+        // NOTE #1: unwrap is safe to use here since intermediate_states is of length 1.
+        // NOTE #2: we need to feed in both the stack and the altstack
+
+        intermediate_states.push(IntermediateState::from_intermediate_result(
+            intermediate_states.last().unwrap(),
+            &shard,
+        ));
+    }
+
+    assert_eq!(
+        intermediate_states.len(),
+        shards.len(),
+        "Intermediate results should be the same as the number of scripts"
+    );
+
+    SplitResult {
+        shards,
+        intermediate_states,
+    }
+}
diff --git a/splitter/src/split/intermediate_state.rs b/bitcoin-splitter/src/split/intermediate_state.rs
similarity index 100%
rename from splitter/src/split/intermediate_state.rs
rename to bitcoin-splitter/src/split/intermediate_state.rs
diff --git a/splitter/src/split/mod.rs b/bitcoin-splitter/src/split/mod.rs
similarity index 100%
rename from splitter/src/split/mod.rs
rename to bitcoin-splitter/src/split/mod.rs
diff --git a/splitter/src/split/script.rs b/bitcoin-splitter/src/split/script.rs
similarity index 77%
rename from splitter/src/split/script.rs
rename to bitcoin-splitter/src/split/script.rs
index 88dd8c1..faeb62b 100644
--- a/splitter/src/split/script.rs
+++ b/bitcoin-splitter/src/split/script.rs
@@ -1,6 +1,11 @@
 //! Module containing the structure for scripts that we are going to use
 
-use super::{core::naive_split, intermediate_state::IntermediateState};
+use core::fmt;
+
+use super::{
+    core::{naive_split, SplitType},
+    intermediate_state::IntermediateState,
+};
 use crate::treepp::*;
 
 /// Structure that represents a pair of input and output scripts. Typically, the prover
@@ -20,6 +25,26 @@ pub struct SplitResult {
     pub intermediate_states: Vec<IntermediateState>,
 }
 
+impl fmt::Debug for SplitResult {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        writeln!(
+            f,
+            "Number of intermediate states: {}",
+            self.intermediate_states.len()
+        )?;
+        // Debugging first and last shards OPCODEs
+        for (i, shard) in self.shards.iter().enumerate() {
+            const MAX_CHARACTERS_TO_SHOW: usize = 100;
+            let s = shard.to_asm_string();
+            let first_opcodes = &s[..MAX_CHARACTERS_TO_SHOW];
+            let last_opcodes = &s[s.len() - MAX_CHARACTERS_TO_SHOW..];
+
+            writeln!(f, "Shard {}: {}...{}", i, first_opcodes, last_opcodes)?;
+        }
+        Ok(())
+    }
+}
+
 impl SplitResult {
     /// Creates a new instance of the SplitResult
     pub fn new(shards: Vec<Script>, intermediate_states: Vec<IntermediateState>) -> Self {
@@ -86,7 +111,7 @@ pub trait SplitableScript<const INPUT_SIZE: usize, const OUTPUT_SIZE: usize> {
     }
 
     /// Splits the script into smaller parts
-    fn split(input: Script) -> SplitResult {
-        naive_split(input, Self::script())
+    fn split(input: Script, split_type: SplitType) -> SplitResult {
+        naive_split(input, Self::script(), split_type)
     }
 }
diff --git a/splitter/src/split/tests.rs b/bitcoin-splitter/src/split/tests.rs
similarity index 86%
rename from splitter/src/split/tests.rs
rename to bitcoin-splitter/src/split/tests.rs
index ba199d3..890aefd 100644
--- a/splitter/src/split/tests.rs
+++ b/bitcoin-splitter/src/split/tests.rs
@@ -1,5 +1,8 @@
 use crate::{
-    split::script::{IOPair, SplitableScript},
+    split::{
+        core::SplitType,
+        script::{IOPair, SplitableScript},
+    },
     test_scripts::int_mul::U254MulScript,
     treepp::*,
     utils::stack_to_script,
@@ -25,10 +28,9 @@ fn test_split_basic() {
     assert!(result.success, "Test script failed");
 
     // Splitting the script into shards
-    let shards = split_into_shards(&test_script, CHUNK_SIZE);
+    let shards = split_into_shards(&test_script, CHUNK_SIZE, SplitType::ByInstructions);
 
-    // Asserting that we have three shards and each shard has at most three elements in the stack
-    assert_eq!(shards.len(), 3, "Shards number is incorrect");
+    // Debugging the shards
     for (i, shard) in shards.clone().into_iter().enumerate() {
         println!("Shard {}: {}", i, shard.to_asm_string());
         println!("Shard {} size: {}", i, shard.len());
@@ -84,7 +86,7 @@ fn test_split_mul() {
     );
 
     // Splitting the script into shards
-    let shards = split_into_shards(&test_script, CHUNK_SIZE);
+    let shards = split_into_shards(&test_script, CHUNK_SIZE, SplitType::ByInstructions);
 
     // Now, we are going to concatenate all the shards and verify that the script is also correct
     let verification_script = script! {
@@ -205,6 +207,42 @@ fn test_state_from_input_script_mainstack_and_altstack_2() {
     assert!(result.success, "altstack verification failed");
 }
 
+#[test]
+fn test_if_split() {
+    const CHUNK_SIZE: usize = 3;
+
+    // Adding input and verification scripts
+    let input_script = script! {
+        { 5 } { 10 }
+    };
+    let main_script = script! {
+        10 OP_EQUAL OP_IF
+            { 20 }
+            OP_ADD
+        OP_ELSE
+            { 50 } OP_ADD
+        OP_ENDIF
+
+        { 20 }
+        OP_ADD
+    };
+
+    // Now, splitting the main_script:
+    let shards = split_into_shards(&main_script, CHUNK_SIZE, SplitType::ByInstructions);
+
+    // Creating the first intermediate state
+    let z1 = IntermediateState::from_input_script(&input_script, &shards[0]);
+
+    // Asserting that both the stack and altstack are correct
+    let verify_main_stack_script = script! {
+        { stack_to_script(&z1.stack) }
+        { 25 } OP_EQUAL
+    };
+
+    let result = execute_script(verify_main_stack_script);
+    assert!(result.success, "z1 mainstack verification failed");
+}
+
 #[test]
 fn test_state_from_state() {
     const CHUNK_SIZE: usize = 3;
@@ -220,7 +258,7 @@ fn test_state_from_state() {
     };
 
     // Now, splitting the main_script:
-    let shards = split_into_shards(&main_script, CHUNK_SIZE);
+    let shards = split_into_shards(&main_script, CHUNK_SIZE, SplitType::ByInstructions);
 
     // Creating the first intermediate state
     let z1 = IntermediateState::from_input_script(&input_script, &shards[0]);
diff --git a/splitter/src/test_scripts/int_add.rs b/bitcoin-splitter/src/test_scripts/int_add.rs
similarity index 94%
rename from splitter/src/test_scripts/int_add.rs
rename to bitcoin-splitter/src/test_scripts/int_add.rs
index 3597447..36149fb 100644
--- a/splitter/src/test_scripts/int_add.rs
+++ b/bitcoin-splitter/src/test_scripts/int_add.rs
@@ -55,7 +55,7 @@ impl SplitableScript<{ INPUT_SIZE }, { OUTPUT_SIZE }> for U254AddScript {
 mod tests {
     use bitcoin_window_mul::traits::comparable::Comparable;
 
-    use crate::utils::stack_to_script;
+    use crate::{split::core::SplitType, utils::stack_to_script};
 
     use super::*;
 
@@ -74,7 +74,7 @@ mod tests {
         );
 
         // Splitting the script into shards
-        let split_result = U254AddScript::split(input.clone());
+        let split_result = U254AddScript::split(input.clone(), SplitType::ByInstructions);
 
         // Now, we are going to concatenate all the shards and verify that the script is also correct
         let verification_script = script! {
@@ -104,7 +104,7 @@ mod tests {
         let IOPair { input, output } = U254AddScript::generate_valid_io_pair();
 
         // Splitting the script into shards
-        let split_result = U254AddScript::split(input);
+        let split_result = U254AddScript::split(input, SplitType::ByInstructions);
 
         // Checking the last state (which must be equal to the result of the multiplication)
         let last_state = split_result.must_last_state();
diff --git a/splitter/src/test_scripts/int_mul.rs b/bitcoin-splitter/src/test_scripts/int_mul.rs
similarity index 92%
rename from splitter/src/test_scripts/int_mul.rs
rename to bitcoin-splitter/src/test_scripts/int_mul.rs
index 1876880..344db53 100644
--- a/splitter/src/test_scripts/int_mul.rs
+++ b/bitcoin-splitter/src/test_scripts/int_mul.rs
@@ -49,7 +49,7 @@ impl SplitableScript<{ INPUT_SIZE }, { OUTPUT_SIZE }> for U254MulScript {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::utils::stack_to_script;
+    use crate::{split::core::SplitType, utils::stack_to_script};
     use bitcoin_window_mul::traits::comparable::Comparable;
 
     #[test]
@@ -67,7 +67,7 @@ mod tests {
         );
 
         // Splitting the script into shards
-        let split_result = U254MulScript::split(input.clone());
+        let split_result = U254MulScript::split(input.clone(), SplitType::ByInstructions);
 
         // Now, we are going to concatenate all the shards and verify that the script is also correct
         let verification_script = script! {
@@ -97,7 +97,10 @@ mod tests {
         let IOPair { input, output } = U254MulScript::generate_valid_io_pair();
 
         // Splitting the script into shards
-        let split_result = U254MulScript::split(input);
+        let split_result = U254MulScript::split(input, SplitType::ByInstructions);
+
+        // Debugging the split result
+        println!("Split result: {:?}", split_result);
 
         // Checking the last state (which must be equal to the result of the multiplication)
         let last_state = split_result.must_last_state();
diff --git a/splitter/src/test_scripts/mod.rs b/bitcoin-splitter/src/test_scripts/mod.rs
similarity index 100%
rename from splitter/src/test_scripts/mod.rs
rename to bitcoin-splitter/src/test_scripts/mod.rs
diff --git a/splitter/src/test_scripts/sha256.rs b/bitcoin-splitter/src/test_scripts/sha256.rs
similarity index 95%
rename from splitter/src/test_scripts/sha256.rs
rename to bitcoin-splitter/src/test_scripts/sha256.rs
index 5161d5c..a6dbd48 100644
--- a/splitter/src/test_scripts/sha256.rs
+++ b/bitcoin-splitter/src/test_scripts/sha256.rs
@@ -48,7 +48,7 @@ impl<const INPUT_SIZE: usize> SplitableScript<INPUT_SIZE, { OUTPUT_SIZE }>
 
 #[cfg(test)]
 mod tests {
-    use crate::utils::stack_to_script;
+    use crate::{split::core::SplitType, utils::stack_to_script};
 
     use super::*;
 
@@ -72,7 +72,7 @@ mod tests {
         );
 
         // Splitting the script into shards
-        let split_result = SHA256ScriptType::split(input.clone());
+        let split_result = SHA256ScriptType::split(input.clone(), SplitType::ByInstructions);
 
         // Now, we are going to concatenate all the shards and verify that the script is also correct
         let verification_script = script! {
@@ -106,7 +106,8 @@ mod tests {
         let IOPair { input, output } = SHA256ScriptType::generate_valid_io_pair();
 
         // Splitting the script into shards
-        let split_result = SHA256ScriptType::split(input);
+        let split_result = SHA256ScriptType::split(input, SplitType::ByInstructions);
+        println!("Split result: {:?}", split_result);
 
         // Checking the last state (which must be equal to the result of the multiplication)
         let last_state = split_result.must_last_state();
diff --git a/splitter/src/utils.rs b/bitcoin-splitter/src/utils.rs
similarity index 100%
rename from splitter/src/utils.rs
rename to bitcoin-splitter/src/utils.rs
diff --git a/splitter/src/split/core.rs b/splitter/src/split/core.rs
deleted file mode 100644
index f2bacb2..0000000
--- a/splitter/src/split/core.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-//! Module containing the logic of splitting the script into smaller parts
-
-use bitcoin::script::Instruction;
-
-use super::script::SplitResult;
-use crate::{split::intermediate_state::IntermediateState, treepp::*};
-
-/// Maximum size of the script in bytes
-pub(super) const MAX_SCRIPT_SIZE: usize = 18000;
-
-// TODO: Currently, the chunk size splits the script into the parts of the same size IN TERMS OF INSTRUCTIONS, not bytes.
-/// Splits the given script into smaller parts
-pub(super) fn split_into_shards(script: &Script, chunk_size: usize) -> Vec<Script> {
-    let instructions: Vec<Instruction> = script
-        .instructions()
-        .map(|instruction| instruction.expect("script is most likely corrupted"))
-        .collect();
-
-    instructions
-        .chunks(chunk_size)
-        .map(|chunk| {
-            let mut shard = Script::new();
-            for instruction in chunk {
-                shard.push_instruction(*instruction);
-            }
-
-            shard
-        })
-        .collect()
-}
-
-pub(super) fn naive_split(input: Script, script: Script) -> SplitResult {
-    // First, we split the script into smaller parts
-    let shards = split_into_shards(&script, MAX_SCRIPT_SIZE);
-    let mut intermediate_states: Vec<IntermediateState> = vec![];
-
-    // Then, we do the following steps:
-    // 1. We execute the first script with the input
-    // 2. We take the stack and write it to the intermediate results
-    // 3. We execute the second script with the saved intermediate results
-    // 4. Take the stask, save to the intermediate results
-    // 5. Repeat until the last script
-
-    intermediate_states.push(IntermediateState::from_input_script(&input, &shards[0]));
-
-    for shard in shards.clone().into_iter().skip(1) {
-        // Executing a piece of the script with the current input.
-        // NOTE #1: unwrap is safe to use here since intermediate_states is of length 1.
-        // NOTE #2: we need to feed in both the stack and the altstack
-
-        intermediate_states.push(IntermediateState::from_intermediate_result(
-            intermediate_states.last().unwrap(),
-            &shard,
-        ));
-    }
-
-    assert_eq!(
-        intermediate_states.len(),
-        shards.len(),
-        "Intermediate results should be the same as the number of scripts"
-    );
-
-    SplitResult {
-        shards,
-        intermediate_states,
-    }
-}

From a18f97a00606661c65ac7400a4ba43db378cc091 Mon Sep 17 00:00:00 2001
From: ZamDimon <zamdmytro@gmail.com>
Date: Mon, 30 Sep 2024 20:23:17 +0300
Subject: [PATCH 17/17] :speech_balloon: add more comments

---
 bitcoin-splitter/src/split/core.rs               | 9 +++++++--
 bitcoin-splitter/src/split/intermediate_state.rs | 3 +++
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/bitcoin-splitter/src/split/core.rs b/bitcoin-splitter/src/split/core.rs
index f8a4d5e..6552f3f 100644
--- a/bitcoin-splitter/src/split/core.rs
+++ b/bitcoin-splitter/src/split/core.rs
@@ -29,8 +29,8 @@ pub enum SplitType {
     ByBytes,
 }
 
-// TODO: Currently, the chunk size splits the script into the parts of the same size IN TERMS OF INSTRUCTIONS, not bytes.
-/// Splits the given script into smaller parts
+/// Splits the given script into smaller parts. Tries to keep each chunk size
+/// to the optimal size ([`OPTIMAL_SCRIPT_SIZE`]) as close as possible.
 pub(super) fn split_into_shards(
     script: &Script,
     chunk_size: usize,
@@ -89,6 +89,11 @@ pub(super) fn split_into_shards(
     shards
 }
 
+/// Naive split of the script into smaller parts. It works as follows:
+/// 1. We split the script into smaller parts
+/// 2. We execute each shard with the input
+/// 3. Save intermediate results
+/// 4. Return all the shards and intermediate results in the form of [`SplitResult`]
 pub(super) fn naive_split(input: Script, script: Script, split_type: SplitType) -> SplitResult {
     // First, we split the script into smaller parts
     let shards = split_into_shards(&script, OPTIMAL_SCRIPT_SIZE, split_type);
diff --git a/bitcoin-splitter/src/split/intermediate_state.rs b/bitcoin-splitter/src/split/intermediate_state.rs
index 14393e8..9cea182 100644
--- a/bitcoin-splitter/src/split/intermediate_state.rs
+++ b/bitcoin-splitter/src/split/intermediate_state.rs
@@ -4,6 +4,9 @@
 use crate::{treepp::*, utils::stack_to_script};
 use bitcoin_scriptexec::Stack;
 
+/// Structure that represents the intermediate state.
+/// It contains the stack and altstack after the execution of the
+/// corresponding shard.
 pub struct IntermediateState {
     pub stack: Stack,
     pub altstack: Stack,