diff --git a/scripts/Cargo.toml b/scripts/Cargo.toml
index 33e0a9a..fc275f3 100644
--- a/scripts/Cargo.toml
+++ b/scripts/Cargo.toml
@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+bitvm = { git = "https://github.com/bitlayer-org/BitVM.git" }
 bitcoin-script = { git = "https://github.com/bitlayer-org/rust-bitcoin-script" }
 bitcoin = { git = "https://github.com/bitlayer-org/rust-bitcoin", branch = "bf-stark" }
 bitcoin-scriptexec = { git = "https://github.com/bitlayer-org/rust-bitcoin-scriptexec" }
diff --git a/scripts/src/hashes/blake3.rs b/scripts/src/hashes/blake3.rs
deleted file mode 100644
index d02b16e..0000000
--- a/scripts/src/hashes/blake3.rs
+++ /dev/null
@@ -1,590 +0,0 @@
-#![allow(non_snake_case)]
-use std::collections::HashMap;
-
-use crate::pseudo::push_to_stack;
-use crate::treepp::{pushable, script, Script};
-use crate::u32::u32_std::{u32_equalverify, u32_roll};
-use crate::u32::{
-    u32_add::u32_add,
-    u32_rrot::u32_rrot,
-    u32_std::{u32_drop, u32_fromaltstack, u32_push, u32_toaltstack},
-    u32_xor::{u32_xor, u8_drop_xor_table, u8_push_xor_table},
-    // unroll,
-};
-
-//
-// Environment
-//
-
-// A pointer to address elements on the stack
-#[derive(Eq, Hash, PartialEq, Debug, Clone, Copy)]
-pub enum Ptr {
-    State(u32),
-    Message(u32),
-}
-
-pub fn S(i: u32) -> Ptr {
-    Ptr::State(i)
-}
-
-pub fn M(i: u32) -> Ptr {
-    Ptr::Message(i)
-}
-
-// An environment to track elements on the stack
-type Env = HashMap<Ptr, u32>;
-
-pub fn ptr_init() -> Env {
-    // Initial positions for state and message
-    let mut env: Env = Env::new();
-    for i in 0..16 {
-        env.insert(S(i), i);
-        // The message's offset is the size of the state
-        // plus the u32 size of our XOR table
-        env.insert(M(i), i + 16 + 256 / 4);
-    }
-    env
-}
-
-pub fn ptr_init_160() -> Env {
-    // Initial positions for state and message
-    let mut env: Env = Env::new();
-    for i in 0..16 {
-        env.insert(S(i), i);
-        // The message's offset is the size of the state
-        // plus the u32 size of our XOR table
-        let value: i32 = i as i32
-            + 16
-            + 256 / 4
-            + match i < 10 {
-                true => 6,
-                false => -10,
-            };
-        env.insert(M(i), value as u32);
-    }
-    env
-}
-
-pub trait EnvTrait {
-    // Get the position of `ptr`
-    fn ptr(&mut self, ptr: Ptr) -> u32;
-
-    /// Get the position of `ptr`, then delete it
-    fn ptr_extract(&mut self, ptr: Ptr) -> u32;
-
-    /// Set the position of `ptr` to the top stack ptr
-    fn ptr_insert(&mut self, ptr: Ptr);
-}
-
-impl EnvTrait for Env {
-    fn ptr_insert(&mut self, ptr: Ptr) {
-        for (_, value) in self.iter_mut() {
-            *value += 1;
-        }
-        self.insert(ptr, 0);
-    }
-
-    fn ptr_extract(&mut self, ptr: Ptr) -> u32 {
-        match self.remove(&ptr) {
-            Some(index) => {
-                for (_, value) in self.iter_mut() {
-                    if index < *value {
-                        *value -= 1;
-                    }
-                }
-                index
-            }
-            None => panic!("{:?}", ptr),
-        }
-    }
-
-    fn ptr(&mut self, ptr: Ptr) -> u32 {
-        *self.get(&ptr).unwrap()
-    }
-}
-
-//
-// Blake 3 Algorithm
-//
-
-const IV: [u32; 8] = [
-    0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19,
-];
-
-const MSG_PERMUTATION: [u32; 16] = [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8];
-
-pub fn initial_state(block_len: u32) -> Vec<Script> {
-    let mut state = [
-        IV[0], IV[1], IV[2], IV[3], IV[4], IV[5], IV[6], IV[7], IV[0], IV[1], IV[2], IV[3], 0, 0,
-        block_len, 0b00001011,
-    ];
-    state.reverse();
-    state.iter().map(|x| u32_push(*x)).collect::<Vec<_>>()
-}
-
-fn G(env: &mut Env, ap: u32, a: Ptr, b: Ptr, c: Ptr, d: Ptr, m0: Ptr, m1: Ptr) -> Script {
-    let script = script! {
-        // z = a+b+m0
-        {u32_add(env.ptr(b), env.ptr_extract(a))}
-        {u32_add(env.ptr(m0) + 1, 0)}
-        // Stack:  m1 m0 d c b  |  z
-
-        // y = (d^z) >>> 16
-        {u32_xor(0, env.ptr_extract(d) + 1, ap + 1)}
-        {u32_rrot(16)}
-        // Stack:  m1 m0 c b  |  z y
-
-
-        // x = y+c
-        {u32_add(0, env.ptr_extract(c) + 2)}
-        // Stack:  m1 m0 b  |  z y x
-
-        // w = (b^x) >>> 12
-        {u32_xor(0, env.ptr_extract(b) + 3, ap + 1)}
-        {u32_rrot(12)}
-        // Stack:  m1 m0 |  z y x w
-
-
-        // v = z+w+m1
-        {u32_add(0, 3)}
-        {u32_add(env.ptr(m1) + 4, 0)}
-        // Stack: m1 m0 |  y x w v
-
-        // u = (y^v) >>> 8
-        {u32_xor(0, 3, ap + 1)}
-        {u32_rrot(8)}
-        // Stack: m1 m0 |  x w v u
-
-        // t = x+u
-        {u32_add(0, 3)}
-        // Stack: m1 m0 |  w v u t
-
-        // s = (w^t) >>> 7
-        {u32_xor(0, 3, ap + 1)}
-        {u32_rrot(7)}
-        // Stack: m1 m0 |  v u t s
-    };
-
-    env.ptr_insert(a);
-    env.ptr_insert(d);
-    env.ptr_insert(c);
-    env.ptr_insert(b);
-    script
-}
-
-pub fn round(env: &mut Env, ap: u32) -> Script {
-    script! {
-        { G(env, ap, S(0), S(4), S(8),  S(12), M(0),  M(1)) }
-        { G(env, ap, S(1), S(5), S(9),  S(13), M(2),  M(3)) }
-        { G(env, ap, S(2), S(6), S(10), S(14), M(4),  M(5)) }
-        { G(env, ap, S(3), S(7), S(11), S(15), M(6),  M(7)) }
-
-        { G(env, ap, S(0), S(5), S(10), S(15), M(8),  M(9)) }
-        { G(env, ap, S(1), S(6), S(11), S(12), M(10), M(11)) }
-        { G(env, ap, S(2), S(7), S(8),  S(13), M(12), M(13)) }
-        { G(env, ap, S(3), S(4), S(9),  S(14), M(14), M(15)) }
-    }
-}
-
-//Script added cause we are getting Non pushable error otherwise, not sure how to...
-pub fn permute(env: &mut Env) -> Script {
-    let mut prev_env = Vec::new();
-    for i in 0..16 {
-        prev_env.push(env.ptr(M(i)));
-    }
-
-    for i in 0..16 {
-        env.insert(M(i as u32), prev_env[MSG_PERMUTATION[i] as usize]);
-    }
-
-    return script! {};
-}
-
-fn compress(env: &mut Env, ap: u32) -> Script {
-    script! {
-        // Perform 7 rounds and permute after each round,
-        // except for the last round
-        {round(env, ap)}
-
-        for _ in 0..6{
-            {permute(env)}
-            {round(env, ap)}
-        }
-
-        // XOR states [0..7] with states [8..15]
-        for i in 0..8{
-            {u32_xor(env.ptr(S(i)) + i, env.ptr_extract(S(i + 8)) + i, ap + 1)}
-        }
-    }
-}
-
-fn compress_160(env: &mut Env, ap: u32) -> Script {
-    script! {
-        // Perform 7 rounds and permute after each round,
-        // except for the last round
-        {round(env, ap)}
-        for _ in 0..6 {
-            {permute(env)}
-            {round(env, ap)}
-        }
-
-        // XOR states [0..4] with states [8..12]
-        for i in 0..5{
-            {u32_xor(env.ptr(S(i)) + i, env.ptr_extract(S(i + 8)) + i, ap + 1)}
-        }
-    }
-}
-
-/// Blake3 taking a 64-byte message and returning a 32-byte digest
-pub fn blake3() -> Script {
-    let mut env = ptr_init();
-    script! {
-        // Initialize our lookup table
-        // We have to do that only once per program
-        u8_push_xor_table
-
-        // Push the initial Blake state onto the stack
-        {initial_state(64)}
-
-        // Perform a round of Blake3
-        {compress(&mut env, 16)}
-
-        // Save the hash
-        for _ in 0..8{
-            {u32_toaltstack()}
-        }
-
-        // Clean up the input data and the other half of the state
-        for _ in 0..24 {
-            {u32_drop()}
-        }
-
-        // Drop the lookup table
-        u8_drop_xor_table
-
-        // Load the hash
-        for _ in 0..8{
-            {u32_fromaltstack()}
-        }
-    }
-}
-
-pub fn blake3_var_length(num_bytes: usize) -> Script {
-    assert!(num_bytes <= 512,
-            "This blake3 implementation does not support input larger than 512 bytes due to stack limit. \
-            Please modify the hashing routine to avoid calling blake3 in this way.");
-
-    // compute how many padding elements are needed
-    let num_blocks = (num_bytes + 64 - 1) / 64;
-    let num_padding_bytes = num_blocks * 64 - num_bytes;
-
-    // adding the padding
-    let mut script_bytes = vec![];
-
-    script_bytes.extend_from_slice(push_to_stack(0, num_padding_bytes).as_bytes());
-
-    // if padded, move all the bytes down
-    if num_padding_bytes != 0 {
-        script_bytes.extend_from_slice(
-            script! {
-                for _ in 0..num_bytes {
-                    { num_bytes + num_padding_bytes - 1 } OP_ROLL
-                }
-            }
-            .as_bytes(),
-        );
-    }
-
-    // Initialize the lookup table
-    script_bytes.extend_from_slice(u8_push_xor_table().as_bytes());
-
-    // Push the initial Blake3 state onto the stack
-    let first_block_flag = if num_bytes <= 64 {
-        0b00001011
-    } else {
-        0b00000001
-    };
-    let init_state = {
-        let mut state = [
-            IV[0],
-            IV[1],
-            IV[2],
-            IV[3],
-            IV[4],
-            IV[5],
-            IV[6],
-            IV[7],
-            IV[0],
-            IV[1],
-            IV[2],
-            IV[3],
-            0,
-            0,
-            core::cmp::min(num_bytes as u32, 64),
-            first_block_flag,
-        ];
-        state.reverse();
-        state.iter().map(|x| u32_push(*x)).collect::<Vec<_>>()
-    };
-    script_bytes.extend_from_slice(
-        script! {
-            { init_state }
-        }
-        .as_bytes(),
-    );
-
-    // reset the pointer system
-    let mut env = ptr_init();
-
-    // store the compression script for reuse
-    let compression_script = script! {
-        {compress(&mut env, 16)}
-
-        { 321 }
-        // Clean up the input data
-        for _ in 0..63 {
-            OP_DUP OP_ROLL OP_DROP
-        }
-        OP_1SUB OP_ROLL OP_DROP
-
-        // Save the hash
-        for _ in 0..8{
-            {u32_toaltstack()}
-        }
-
-        // Clean up the other half of the state
-        for _ in 0..8 {
-            {u32_drop()}
-        }
-    };
-
-    // call the compression function
-    script_bytes.extend_from_slice(compression_script.as_bytes());
-
-    // for the rest of the blocks
-    let mut num_bytes = num_bytes;
-    for i in 1..num_blocks {
-        num_bytes -= 64;
-
-        let block_flag = if i == num_blocks - 1 { 0b00001010 } else { 0 };
-
-        let state_add = {
-            let mut state = [
-                IV[0],
-                IV[1],
-                IV[2],
-                IV[3],
-                0,
-                0,
-                core::cmp::min(num_bytes as u32, 64),
-                block_flag,
-            ];
-            state.reverse();
-            state.iter().map(|x| u32_push(*x)).collect::<Vec<_>>()
-        };
-
-        script_bytes.extend_from_slice(
-            script! {
-                { state_add }
-                for _ in 0..8 {
-                    {u32_fromaltstack()}
-                }
-                for i in 1..8 {
-                    {u32_roll(i)}
-                }
-                {compression_script.clone()}
-            }
-            .as_bytes(),
-        );
-    }
-
-    script_bytes.extend_from_slice(
-        script! {
-            u8_drop_xor_table
-            for _ in 0..8 {
-                {u32_fromaltstack()}
-            }
-        }
-        .as_bytes(),
-    );
-
-    Script::from(script_bytes)
-}
-
-/// Blake3 taking a 40-byte message and returning a 20-byte digest
-pub fn blake3_160() -> Script {
-    let mut env = ptr_init_160();
-    script! {
-        // Message zero-padding to 64-byte block
-        // for _ in 0..6{
-        //     {u32_push(0)}
-        // }
-        { push_to_stack(0,24) }
-
-        // Initialize our lookup table
-        // We have to do that only once per program
-        u8_push_xor_table
-
-        // Push the initial Blake state onto the stack
-        {initial_state(40)}
-
-        // Perform a round of Blake3
-        {compress_160(&mut env, 16)}
-
-        // Save the hash
-        for _ in 0..5{
-            {u32_toaltstack()}
-        }
-
-        // Clean up the input data and the other half of the state
-        for _ in 0..27{
-            {u32_drop()}
-        }
-
-        // Drop the lookup table
-        u8_drop_xor_table
-
-        // Load the hash
-        for _ in 0..5{
-            {u32_fromaltstack()}
-        }
-    }
-}
-
-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 }
-        }
-    }
-}
-
-pub fn blake3_hash_equalverify() -> Script {
-    script! {
-        for _ in 0..28 {
-            OP_TOALTSTACK
-        }
-        {u32_equalverify()}
-        for _ in 0..7 {
-            OP_FROMALTSTACK OP_FROMALTSTACK OP_FROMALTSTACK OP_FROMALTSTACK
-            {u32_equalverify()}
-        }
-    }
-}
-
-pub fn blake3_160_hash_equalverify() -> Script {
-    script! {
-        for _ in 0..16 {
-            OP_TOALTSTACK
-        }
-        {u32_equalverify()}
-        for _ in 0..4 {
-            OP_FROMALTSTACK OP_FROMALTSTACK OP_FROMALTSTACK OP_FROMALTSTACK
-            {u32_equalverify()}
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::hashes::blake3::*;
-    use crate::treepp::{execute_script, script};
-
-    #[test]
-    fn test_permute() {
-        let mut env = ptr_init();
-        // println!("Start env: {}", round(&mut env, 16).to_hex_string());
-        permute(&mut env);
-        // println!("Permuted env: {:?}", env);
-        assert!(env.ptr(M(0)) == 82);
-        assert!(env.ptr(M(1)) == 86);
-        assert!(env.ptr(M(2)) == 83);
-        assert!(env.ptr(M(3)) == 90);
-        assert!(env.ptr(M(4)) == 87);
-        assert!(env.ptr(M(5)) == 80);
-        assert!(env.ptr(M(6)) == 84);
-        assert!(env.ptr(M(7)) == 93);
-        assert!(env.ptr(M(8)) == 81);
-        assert!(env.ptr(M(9)) == 91);
-        assert!(env.ptr(M(10)) == 92);
-        assert!(env.ptr(M(11)) == 85);
-        assert!(env.ptr(M(12)) == 89);
-        assert!(env.ptr(M(13)) == 94);
-        assert!(env.ptr(M(14)) == 95);
-        assert!(env.ptr(M(15)) == 88);
-    }
-
-    #[test]
-    fn test_initial_state() {
-        let script = script! {
-            {initial_state(64)}
-        };
-        let res = execute_script(script);
-        assert!(res.final_stack.get(17)[0] == 79);
-    }
-
-    #[test]
-    fn test_blake3() {
-        let hex_out = "86ca95aefdee3d969af9bcc78b48a5c1115be5d66cafc2fc106bbd982d820e70";
-
-        let script = script! {
-            for _ in 0..16{
-                {u32_push(1)}
-            }
-            blake3
-            {push_bytes_hex(hex_out)}
-            {blake3_hash_equalverify()}
-            OP_TRUE
-        };
-        let res = execute_script(script);
-        assert!(res.success);
-    }
-
-    #[test]
-    fn test_blake3_var_length() {
-        let hex_out = "11b4167bd0184b9fc8b3474a4c29d08e801cbc1596b63a5ab380ce0fc83a15cd";
-
-        let script = script! {
-            for _ in 0..15 {
-                {u32_push(1)}
-            }
-            { blake3_var_length(60) }
-            {push_bytes_hex(hex_out)}
-            {blake3_hash_equalverify()}
-            OP_TRUE
-        };
-        println!("Blake3_var_length_60 size: {:?} \n", script.len());
-
-        let res = execute_script(script);
-        assert!(res.success);
-    }
-
-    #[test]
-    fn test_blake3_160() {
-        let hex_out = "290eef2c4633e64835e2ea6395e9fc3e8bf459a7";
-
-        let script = script! {
-            for _ in 0..10{
-                {u32_push(1)}
-            }
-            blake3_160
-            {push_bytes_hex(hex_out)}
-            blake3_160_hash_equalverify
-            OP_TRUE
-        };
-        println!("Blake3 size: {:?} \n", script.len());
-        let res = execute_script(script);
-
-        assert!(res.success);
-    }
-}
diff --git a/scripts/src/hashes/mod.rs b/scripts/src/hashes/mod.rs
deleted file mode 100644
index 6bc7d82..0000000
--- a/scripts/src/hashes/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub mod blake3;
diff --git a/scripts/src/lib.rs b/scripts/src/lib.rs
index bf779e2..c600048 100644
--- a/scripts/src/lib.rs
+++ b/scripts/src/lib.rs
@@ -10,13 +10,10 @@ use bitcoin_scriptexec::{Exec, ExecCtx, ExecutionResult, Options, TxTemplate};
 pub mod bit_comm;
 pub use bit_comm::*;
 
-mod u32;
-pub use u32::*;
-
 pub mod pseudo;
 
-mod hashes;
-pub use hashes::*;
+pub use bitvm::hash::blake3;
+pub use bitvm::u32::*;
 
 define_pushable!();
 
diff --git a/scripts/src/u31/babybear.rs b/scripts/src/u31/babybear.rs
deleted file mode 100644
index a971137..0000000
--- a/scripts/src/u31/babybear.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-use bitcoin::opcodes::{OP_DUP, OP_SWAP};
-use bitcoin::ScriptBuf as Script;
-use bitcoin_script::{define_pushable, script};
-use p3_field::{AbstractField, TwoAdicField};
-use p3_util::{log2_ceil_u64, log2_ceil_usize, log2_strict_usize, reverse_bits_len};
-
-use crate::u31::{babybear, U31Config};
-use crate::{u31_double, u31_mul};
-
-pub struct BabyBearU31;
-impl U31Config for BabyBearU31 {
-    const MOD: u32 = 15 * (1 << 27) + 1;
-}
diff --git a/scripts/src/u31/mod.rs b/scripts/src/u31/mod.rs
deleted file mode 100644
index f56ef5b..0000000
--- a/scripts/src/u31/mod.rs
+++ /dev/null
@@ -1,365 +0,0 @@
-use std::usize;
-
-use bitcoin::ScriptBuf as Script;
-use bitcoin_script::script;
-
-use crate::{pushable, unroll};
-mod m31;
-pub use m31::*;
-
-mod babybear;
-pub use babybear::*;
-
-pub trait U31Config {
-    const MOD: u32;
-}
-
-fn u31_adjust<M: U31Config>() -> Script {
-    script! {
-        OP_DUP
-        0 OP_LESSTHAN
-        OP_IF { M::MOD } OP_ADD OP_ENDIF
-    }
-}
-
-pub fn u31_add<M: U31Config>() -> Script {
-    script! {
-        { M::MOD } OP_SUB
-        OP_ADD
-        { u31_adjust::<M>() }
-    }
-}
-
-pub fn u31_double<M: U31Config>() -> Script {
-    script! {
-        OP_DUP
-        { u31_add::<M>() }
-    }
-}
-
-pub fn u31_sub<M: U31Config>() -> Script {
-    script! {
-        OP_SUB
-        { u31_adjust::<M>() }
-    }
-}
-
-pub fn u31_equalverify() -> Script {
-    script! {
-        OP_EQUALVERIFY
-    }
-}
-
-pub fn u31_to_bits() -> Script {
-    script! {
-        {
-            unroll(30, |i| {
-                let a = 1 << (30 - i);
-                let b = a - 1;
-                script! {
-                    OP_DUP
-                    { b } OP_GREATERTHAN
-                    OP_SWAP OP_OVER
-                    OP_IF { a } OP_SUB OP_ENDIF
-                }
-        })}
-    }
-}
-
-pub fn u31_mul<M: U31Config>() -> Script {
-    script! {
-        u31_to_bits
-        { unroll(31, |_| script! {
-            OP_TOALTSTACK
-        }) }
-        0
-        OP_SWAP
-        OP_DUP
-        { u31_double::<M>() }
-        OP_2DUP
-        { u31_add::<M>() }
-        0
-        OP_FROMALTSTACK
-        OP_IF
-            3 OP_PICK
-            { u31_add::<M>() }
-        OP_ENDIF
-        { u31_double::<M>() }
-        { u31_double::<M>() }
-        { unroll(14, |_| script! {
-            OP_FROMALTSTACK
-            OP_FROMALTSTACK
-            OP_SWAP OP_DUP OP_ADD OP_ADD
-            4 OP_SWAP OP_SUB OP_PICK
-            { u31_add::<M>() }
-            { u31_double::<M>() }
-            { u31_double::<M>() }
-        })}
-        OP_FROMALTSTACK
-        OP_FROMALTSTACK
-        OP_SWAP OP_DUP OP_ADD OP_ADD
-        4 OP_SWAP OP_SUB OP_PICK
-        { u31_add::<M>() }
-        OP_TOALTSTACK
-        OP_2DROP OP_2DROP
-        OP_FROMALTSTACK
-    }
-}
-
-pub fn convert_digits_to_u32<const DIGITS_BITSIZE: usize, const DIGITS_NUM: usize>() -> Script {
-    //0x87654321;
-    // The stack before convert_D_to_u31 looks like(DIGITS_BITSIZE=8,DIGITS_NUM=4 ):
-    // 0x21
-    // 0x43
-    // 0x65
-    // 0x87
-    script! {
-        // The Top Element of the stack is the lowest-bit-value and does not need to be dealed.
-        OP_TOALTSTACK
-        for i in 1..DIGITS_NUM{
-            // STACK:[a,b]  OP_LSHIFT:Logical left shift b bits. Sign data is discarded
-            {DIGITS_BITSIZE}
-            OP_SWAP
-            OP_LSHIFT
-            OP_FROMALTSTACK
-            OP_ADD
-            OP_TOALTSTACK
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use bitcoin::opcodes::OP_EQUALVERIFY;
-    use bitcoin::Script;
-    use p3_baby_bear::BabyBear;
-    use rand::{Rng, SeedableRng};
-    use rand_chacha::ChaCha20Rng;
-
-    use super::*;
-    use crate::execute_script;
-    #[test]
-    fn test_rot() {
-        let scripts = script! {
-            OP_2
-            OP_5
-            OP_3
-            OP_3DUP
-            OP_ROT
-            OP_ADD
-            OP_EQUALVERIFY
-            OP_ROT
-            OP_ADD
-            OP_EQUAL
-        };
-        let result = execute_script(scripts);
-        assert!(result.success);
-    }
-
-    #[test]
-    fn test_u32_add() {
-        let v1: u32 = 0x1BCDEF12;
-        let v2: u32 = 0x1BCDEFf0;
-        let v1_babybear = v1 % BabyBearU31::MOD;
-        let v2_babybear = v2 % BabyBearU31::MOD;
-        let sum_babybear = (v1_babybear + v2_babybear) % BabyBearU31::MOD;
-        let script = script! {
-            { v1_babybear }
-            { v2_babybear }
-            { u31_add::<M31>() }
-            { sum_babybear }
-            OP_EQUAL
-        };
-        println!("{:}", script);
-        let exec_result = execute_script(script);
-        assert!(exec_result.success);
-    }
-
-    #[test]
-    fn test_u31_add() {
-        let mut prng = ChaCha20Rng::seed_from_u64(0u64);
-        eprintln!("u31 add: {}", u31_add::<BabyBearU31>().len());
-
-        for _ in 0..100 {
-            let a: u32 = prng.gen();
-            let b: u32 = prng.gen();
-
-            let a_m31 = a % M31::MOD;
-            let b_m31 = b % M31::MOD;
-            let sum_m31 = (a_m31 + b_m31) % M31::MOD;
-
-            let script = script! {
-                { a_m31 }
-                { b_m31 }
-                { u31_add::<M31>() }
-                { sum_m31 }
-                OP_EQUAL
-            };
-            let exec_result = execute_script(script);
-            assert!(exec_result.success);
-        }
-
-        for _ in 0..100 {
-            let a: u32 = prng.gen();
-            let b: u32 = prng.gen();
-
-            let a_babybear = a % BabyBearU31::MOD;
-            let b_babybear = b % BabyBearU31::MOD;
-            let sum_babybear = (a_babybear + b_babybear) % BabyBearU31::MOD;
-
-            let script = script! {
-                { a_babybear }
-                { b_babybear }
-                { u31_add::<BabyBearU31>() }
-                { sum_babybear }
-                OP_EQUAL
-            };
-            let exec_result = execute_script(script);
-            assert!(exec_result.success)
-        }
-    }
-
-    #[test]
-    fn test_u31_sub() {
-        let mut prng = ChaCha20Rng::seed_from_u64(0u64);
-        eprintln!("u31 sub: {}", u31_sub::<BabyBearU31>().len());
-
-        for _ in 0..100 {
-            let a: u32 = prng.gen();
-            let b: u32 = prng.gen();
-
-            let a_m31 = a % M31::MOD;
-            let b_m31 = b % M31::MOD;
-            let diff_m31 = (M31::MOD + a_m31 - b_m31) % M31::MOD;
-
-            let script = script! {
-                { a_m31 }
-                { b_m31 }
-                { u31_sub::<M31>() }
-                { diff_m31 }
-                OP_EQUAL
-            };
-            let exec_result = execute_script(script);
-            assert!(exec_result.success);
-        }
-
-        for _ in 0..100 {
-            let a: u32 = prng.gen();
-            let b: u32 = prng.gen();
-
-            let a_babybear = a % BabyBearU31::MOD;
-            let b_babybear = b % BabyBearU31::MOD;
-            let diff_babybear = (BabyBearU31::MOD + a_babybear - b_babybear) % BabyBearU31::MOD;
-
-            let script = script! {
-                { a_babybear }
-                { b_babybear }
-                { u31_sub::<BabyBearU31>() }
-                { diff_babybear }
-                OP_EQUAL
-            };
-            let exec_result = execute_script(script);
-            assert!(exec_result.success)
-        }
-    }
-
-    #[test]
-    fn test_u31_to_bits() {
-        let mut prng = ChaCha20Rng::seed_from_u64(0u64);
-
-        for _ in 0..100 {
-            let a: u32 = prng.gen();
-            let m31 = a % M31::MOD;
-
-            let mut bits = vec![];
-            let mut cur = m31;
-            for _ in 0..31 {
-                bits.push(cur % 2);
-                cur >>= 1;
-            }
-            assert_eq!(cur, 0);
-
-            let script = script! {
-                { m31 }
-                u31_to_bits
-                { unroll(30, |i| script! {
-                    { bits[i as usize] } OP_EQUALVERIFY
-                })}
-                { bits[30] } OP_EQUAL
-            };
-            let exec_result = execute_script(script);
-            assert!(exec_result.success);
-        }
-
-        for _ in 0..100 {
-            let a: u32 = prng.gen();
-            let babybear = a % BabyBearU31::MOD;
-
-            let mut bits = vec![];
-            let mut cur = babybear;
-            for _ in 0..31 {
-                bits.push(cur % 2);
-                cur >>= 1;
-            }
-            assert_eq!(cur, 0);
-
-            let script = script! {
-                { babybear }
-                u31_to_bits
-                { unroll(30, |i| script! {
-                    { bits[i as usize] } OP_EQUALVERIFY
-                })}
-                { bits[30] } OP_EQUAL
-            };
-            let exec_result = execute_script(script);
-            assert!(exec_result.success);
-        }
-    }
-
-    #[test]
-    fn test_u31_mul() {
-        let mut prng = ChaCha20Rng::seed_from_u64(6u64);
-        eprintln!("u31 mul: {}", u31_mul::<BabyBearU31>().len());
-
-        for _ in 0..100 {
-            let a: u32 = prng.gen();
-            let b: u32 = prng.gen();
-
-            let a_m31 = a % M31::MOD;
-            let b_m31 = b % M31::MOD;
-            let prod_m31 =
-                ((((a_m31 as u64) * (b_m31 as u64)) % (M31::MOD as u64)) & 0xffffffff) as u32;
-
-            let script = script! {
-                { a_m31 }
-                { b_m31 }
-                { u31_mul::<M31>() }
-                { prod_m31 }
-                OP_EQUAL
-            };
-            let exec_result = execute_script(script);
-            assert!(exec_result.success);
-        }
-
-        for _ in 0..100 {
-            let a: u32 = prng.gen();
-            let b: u32 = prng.gen();
-
-            let a_babybear = a % BabyBearU31::MOD;
-            let b_babybear = b % BabyBearU31::MOD;
-            let prod_babybear = ((((a_babybear as u64) * (b_babybear as u64))
-                % (BabyBearU31::MOD as u64))
-                & 0xffffffff) as u32;
-
-            let script = script! {
-                { a_babybear }
-                { b_babybear }
-                { u31_mul::<BabyBearU31>() }
-                { prod_babybear }
-                OP_EQUAL
-            };
-            let exec_result = execute_script(script);
-            assert!(exec_result.success)
-        }
-    }
-}
diff --git a/scripts/src/u31_ext/mod.rs b/scripts/src/u31_ext/mod.rs
deleted file mode 100644
index fa9b781..0000000
--- a/scripts/src/u31_ext/mod.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-use bitcoin::ScriptBuf as Script;
-use bitcoin_script::script;
-use p3_field::PrimeField32;
-
-use crate::{pushable, unroll};
-
-mod babybear;
-pub use babybear::*;
-
-mod m31;
-pub use m31::*;
-
-mod karatsuba;
-pub use karatsuba::*;
-
-mod karatsuba_complex;
-pub use karatsuba_complex::*;
-
-use crate::u31::{u31_add, u31_double, u31_sub, U31Config};
-
-pub trait U31ExtConfig {
-    type BaseFieldConfig: U31Config;
-    const DEGREE: u32;
-
-    fn mul_impl() -> Script;
-}
-
-pub fn u31ext_add<C: U31ExtConfig>() -> Script {
-    script! {
-        { unroll(C::DEGREE - 1, |i| {
-            let gap = C::DEGREE - i;
-            script!{
-                { gap } OP_ROLL
-                { u31_add::<C::BaseFieldConfig>() }
-                OP_TOALTSTACK
-        }}) }
-        { u31_add::<C::BaseFieldConfig>() }
-        { unroll(C::DEGREE - 1, |_| script!{ OP_FROMALTSTACK }) }
-    }
-}
-
-pub fn u31ext_equalverify<C: U31ExtConfig>() -> Script {
-    script! {
-        { unroll(C::DEGREE - 1, |i| {
-            let gap = C::DEGREE - i;
-            script!{
-                { gap } OP_ROLL
-                OP_EQUALVERIFY
-        }}) }
-        OP_EQUALVERIFY
-    }
-}
-
-pub fn u31ext_sub<C: U31ExtConfig>() -> Script {
-    script! {
-        { unroll(C::DEGREE - 1, |i| {
-            let gap = C::DEGREE - i;
-            script!{
-                { gap } OP_ROLL OP_SWAP
-                { u31_sub::<C::BaseFieldConfig>() }
-                OP_TOALTSTACK
-        }}) }
-        { u31_sub::<C::BaseFieldConfig>() }
-        { unroll(C::DEGREE - 1, |_| script!{ OP_FROMALTSTACK }) }
-    }
-}
-
-pub fn u31ext_double<C: U31ExtConfig>() -> Script {
-    script! {
-        { unroll(C::DEGREE - 1, |_|
-            script! {
-                { u31_double::<C::BaseFieldConfig>() }
-                OP_TOALTSTACK
-        })}
-        { u31_double::<C::BaseFieldConfig>() }
-        { unroll(C::DEGREE - 1, |_| script!{ OP_FROMALTSTACK }) }
-    }
-}
-
-pub fn u31ext_mul<C: U31ExtConfig>() -> Script {
-    C::mul_impl()
-}
diff --git a/scripts/src/u32/mod.rs b/scripts/src/u32/mod.rs
deleted file mode 100644
index 8590513..0000000
--- a/scripts/src/u32/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-pub mod u32_add;
-pub mod u32_rrot;
-pub mod u32_std;
-pub mod u32_xor;
-pub mod u32_zip;
diff --git a/scripts/src/u32/u32_add.rs b/scripts/src/u32/u32_add.rs
deleted file mode 100644
index 726abac..0000000
--- a/scripts/src/u32/u32_add.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-use crate::treepp::{pushable, script, Script};
-use crate::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::treepp::{execute_script, script};
-    use crate::u32::u32_add::*;
-    use crate::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
-        };
-        let exec_result = execute_script(script);
-        assert!(exec_result.success)
-    }
-}
diff --git a/scripts/src/u32/u32_rrot.rs b/scripts/src/u32/u32_rrot.rs
deleted file mode 100644
index 5baa7df..0000000
--- a/scripts/src/u32/u32_rrot.rs
+++ /dev/null
@@ -1,261 +0,0 @@
-#![allow(dead_code)]
-
-use core::panic;
-
-use crate::treepp::{pushable, script, Script};
-
-/// 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
-        return 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);
-    match specific_optimize(rot_num) {
-        Some(res) => return res,
-        None => {}
-    }
-    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 rand::Rng;
-
-    use crate::treepp::{execute_script, script};
-    use crate::u32::u32_rrot::*;
-    use crate::u32::u32_std::*;
-
-    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 exec_script = script! {
-                    {u32_push(x)}
-                    {u32_rrot(i)}
-                    {u32_push(rrot(x, i))}
-                    {u32_equal()}
-                };
-                let res = execute_script(exec_script);
-                assert_eq!(res.success, true);
-            }
-        }
-    }
-}
diff --git a/scripts/src/u32/u32_std.rs b/scripts/src/u32/u32_std.rs
deleted file mode 100644
index 723bd45..0000000
--- a/scripts/src/u32/u32_std.rs
+++ /dev/null
@@ -1,230 +0,0 @@
-#![allow(dead_code)]
-
-use crate::pseudo::{OP_256MUL, OP_4DUP};
-use crate::treepp::{pushable, script, Script};
-
-/// Pushes a value as u32 element onto the stack
-pub fn u32_push(value: u32) -> Script {
-    script! {
-        {value >> 24 & 0xff} // high position
-        {value >> 16 & 0xff}
-        {value >>  8 & 0xff}
-        {value >>  0 & 0xff} // low position
-    }
-}
-
-/// 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 {
-    // input origin value: 0x87654321
-    // the input stack state is:
-    // 21
-    // 43
-    // 56
-    // 87
-    script! {
-        OP_SWAP
-        OP_ROT // The 3rd item down the stack is moved to the top.
-        3
-        OP_ROLL // The item n back in the stack is moved to the top.
-        // At there the stack is reversed as:
-        // 87
-        // 56
-        // 43
-        // 21
-
-        OP_DUP
-        127
-        OP_GREATERTHAN
-        OP_IF
-            128
-            OP_SUB
-            1
-        OP_ELSE
-            0
-        OP_ENDIF
-        OP_TOALTSTACK
-        // the below calculate the mark
-
-
-         //the stack state is:
-        // 87
-        // 56
-        // 43
-        // 21
-        OP_256MUL
-        OP_ADD
-        // 0x87 * 256 + 0x56 = r1
-        OP_256MUL
-        OP_ADD
-        // r1 * 256 + 0x43 = r2
-
-        OP_256MUL
-        OP_ADD
-        // r2 * 256 + 0x21  = result
-
-        OP_FROMALTSTACK
-        OP_IF
-            OP_NEGATE
-        OP_ENDIF
-    }
-}
-
-#[cfg(test)]
-mod test {
-
-    use rand::Rng;
-
-    use crate::treepp::{execute_script, script};
-    use crate::u32::u32_std::*;
-
-    #[test]
-    fn test_u32_push() {
-        let script = script! {
-            { u32_push(0x01020304) }
-            0x04
-            OP_EQUALVERIFY
-            0x03
-            OP_EQUALVERIFY
-            0x02
-            OP_EQUALVERIFY
-            0x01
-            OP_EQUAL
-        };
-
-        assert!(execute_script(script).success)
-    }
-
-    #[test]
-    fn test_wtih_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_value0 = 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
-
-            };
-
-            let exec_result = execute_script(script);
-            assert!(exec_result.success);
-        }
-    }
-}
diff --git a/scripts/src/u32/u32_xor.rs b/scripts/src/u32/u32_xor.rs
deleted file mode 100644
index 95ffb9d..0000000
--- a/scripts/src/u32/u32_xor.rs
+++ /dev/null
@@ -1,338 +0,0 @@
-#![allow(dead_code)]
-
-use crate::treepp::{pushable, script, Script};
-use crate::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_SWAP
-        OP_DUP
-        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
-        }
-    }
-}
diff --git a/scripts/src/u32/u32_zip.rs b/scripts/src/u32/u32_zip.rs
deleted file mode 100644
index e695581..0000000
--- a/scripts/src/u32/u32_zip.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-#![allow(dead_code)]
-use crate::treepp::{pushable, script, Script};
-
-/// 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+0} 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+0} 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+0} 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
-    }
-}