diff --git a/crates/e2e-move-tests/src/tests/move_unit.rs b/crates/e2e-move-tests/src/tests/move_unit.rs
index f59e2290..e7bd1455 100644
--- a/crates/e2e-move-tests/src/tests/move_unit.rs
+++ b/crates/e2e-move-tests/src/tests/move_unit.rs
@@ -18,9 +18,9 @@ use initia_move_types::metadata;
 
 use move_cli::base::test::{run_move_unit_tests_with_factory, UnitTestResult};
 use move_core_types::effects::ChangeSet;
+use move_model::metadata::{CompilerVersion, LanguageVersion};
 use move_unit_test::UnitTestingConfig;
 use move_vm_runtime::native_extensions::NativeContextExtensions;
-use move_model::metadata::{CompilerVersion, LanguageVersion};
 
 use once_cell::sync::Lazy;
 use std::path::PathBuf;
diff --git a/crates/natives/src/block.rs b/crates/natives/src/block.rs
index c9017ce1..6f1f28f8 100644
--- a/crates/natives/src/block.rs
+++ b/crates/natives/src/block.rs
@@ -60,7 +60,7 @@ fn native_test_only_set_block_info(
     let height = safely_pop_arg!(arguments, u64);
 
     let block_context = context.extensions_mut().get_mut::<NativeBlockContext>();
-    NativeBlockContext::set_block_info(block_context, height, timestamp);
+    block_context.set_block_info(height, timestamp);
 
     Ok(smallvec![])
 }
diff --git a/crates/storage/src/module_cache.rs b/crates/storage/src/module_cache.rs
index 62f056a8..4a94aac7 100644
--- a/crates/storage/src/module_cache.rs
+++ b/crates/storage/src/module_cache.rs
@@ -51,16 +51,18 @@ impl WithHash for BytesWithHash {
 pub struct NoVersion;
 
 pub struct InitiaModuleCache {
+    pub capacity: usize,
     #[allow(clippy::type_complexity)]
     pub(crate) module_cache: Mutex<CLruCache<Checksum, ModuleWrapper, RandomState, ModuleScale>>,
 }
 
 impl InitiaModuleCache {
     pub fn new(cache_capacity: usize) -> Arc<InitiaModuleCache> {
-        let capacity = NonZeroUsize::new(cache_capacity * 1024 * 1024).unwrap();
+        let capacity = cache_capacity * 1024 * 1024;
         Arc::new(InitiaModuleCache {
+            capacity,
             module_cache: Mutex::new(CLruCache::with_config(
-                CLruCacheConfig::new(capacity).with_scale(ModuleScale),
+                CLruCacheConfig::new(NonZeroUsize::new(capacity).unwrap()).with_scale(ModuleScale),
             )),
         })
     }
@@ -77,6 +79,16 @@ impl InitiaModuleCache {
         extension: Arc<BytesWithHash>,
         version: NoVersion,
     ) -> VMResult<()> {
+        // cache is too small to hold this module
+        if self.capacity < allocated_size {
+            eprintln!(
+                "Module cache is too small to hold module with size {}",
+                allocated_size
+            );
+
+            return Ok(());
+        }
+
         let mut module_cache = self.module_cache.lock();
 
         match module_cache.get(&key) {
@@ -89,12 +101,12 @@ impl InitiaModuleCache {
                     extension,
                     version,
                 ));
+
+                // NOTE: We are not handling the error here, because we are sure that the
+                // allocated size is less than the capacity.
                 module_cache
                     .put_with_weight(key, ModuleWrapper::new(module, allocated_size))
-                    .unwrap_or_else(|_| {
-                        eprintln!("WARNING: failed to insert module {:?} into cache; cache capacity might be too small", module_id.short_str_lossless().to_string());
-                        None
-                    });
+                    .unwrap_or_else(|_| None);
                 Ok(())
             }
         }
@@ -114,14 +126,20 @@ impl InitiaModuleCache {
                 Ok(module_wrapper.module_code.clone())
             }
             _ => {
-                let module_id = verified_code.self_id();
                 let module = Arc::new(ModuleCode::from_verified(verified_code, extension, version));
-                module_cache
-                    .put_with_weight(key, ModuleWrapper::new(module.clone(), allocated_size))
-                    .unwrap_or_else(|_| {
-                        eprintln!("WARNING: failed to insert module {:?} into cache; cache capacity might be too small", module_id.short_str_lossless().to_string());
-                        None
-                    });
+                if self.capacity >= allocated_size {
+                    // NOTE: We are not handling the error here, because we are sure that the
+                    // allocated size is less than the capacity.
+                    module_cache
+                        .put_with_weight(key, ModuleWrapper::new(module.clone(), allocated_size))
+                        .unwrap_or_else(|_| None);
+                } else {
+                    eprintln!(
+                        "Module cache is too small to hold module with size {}",
+                        allocated_size
+                    );
+                }
+
                 Ok(module)
             }
         }
@@ -156,12 +174,19 @@ impl InitiaModuleCache {
                         }
 
                         let code_wrapper = ModuleWrapper::new(Arc::new(code), allocated_size);
-                        module_cache
-                            .put_with_weight(*checksum, code_wrapper.clone())
-                            .unwrap_or_else(|_| {
-                                eprintln!("WARNING: failed to insert module {:?} into cache; cache capacity might be too small", id.short_str_lossless().to_string());
-                                None
-                            });
+                        if self.capacity >= allocated_size {
+                            // NOTE: We are not handling the error here, because we are sure that the
+                            // allocated size is less than the capacity.
+                            module_cache
+                                .put_with_weight(*checksum, code_wrapper.clone())
+                                .unwrap_or_else(|_| None);
+                        } else {
+                            eprintln!(
+                                "Module cache is too small to hold module with size {}",
+                                allocated_size
+                            );
+                        }
+
                         Some(code_wrapper)
                     }
                     None => None,
diff --git a/crates/storage/src/script_cache.rs b/crates/storage/src/script_cache.rs
index bcc0f505..e7ee9d94 100644
--- a/crates/storage/src/script_cache.rs
+++ b/crates/storage/src/script_cache.rs
@@ -12,15 +12,17 @@ use crate::{
 };
 
 pub struct InitiaScriptCache {
+    pub capacity: usize,
     pub(crate) script_cache: Mutex<CLruCache<Checksum, ScriptWrapper, RandomState, ScriptScale>>,
 }
 
 impl InitiaScriptCache {
     pub fn new(cache_capacity: usize) -> Arc<InitiaScriptCache> {
+        let capacity = cache_capacity * 1024 * 1024;
         Arc::new(InitiaScriptCache {
+            capacity,
             script_cache: Mutex::new(CLruCache::with_config(
-                CLruCacheConfig::new(NonZeroUsize::new(cache_capacity * 1024 * 1024).unwrap())
-                    .with_scale(ScriptScale),
+                CLruCacheConfig::new(NonZeroUsize::new(capacity).unwrap()).with_scale(ScriptScale),
             )),
         })
     }
@@ -42,13 +44,18 @@ impl InitiaScriptCache {
                 let new_script = Code::from_deserialized(deserialized_script);
                 let deserialized_script = new_script.deserialized().clone();
 
-                // error occurs when the new script has a weight greater than the cache capacity
-                script_cache
-                    .put_with_weight(key, ScriptWrapper::new(new_script, allocated_size))
-                    .unwrap_or_else(|_| {
-                        eprintln!("WARNING: failed to insert script into cache; cache capacity might be too small");
-                        None
-                    });
+                if self.capacity >= allocated_size {
+                    // NOTE: We are not handling the error here, because we are sure that the
+                    // allocated size is less than the capacity.
+                    let _ = script_cache
+                        .put_with_weight(key, ScriptWrapper::new(new_script, allocated_size))
+                        .unwrap_or_else(|_| None);
+                } else {
+                    eprintln!(
+                        "Script cache is too small to hold module with size {}",
+                        allocated_size
+                    );
+                }
 
                 Ok(deserialized_script)
             }
@@ -81,12 +88,18 @@ impl InitiaScriptCache {
         };
 
         if let Some(new_script) = new_script {
-            script_cache
-                .put_with_weight(key, ScriptWrapper::new(new_script, allocated_size))
-                .unwrap_or_else(|_| {
-                    eprintln!("WARNING: failed to insert script into cache; cache capacity might be too small");
-                    None
-                });
+            if self.capacity >= allocated_size {
+                // NOTE: We are not handling the error here, because we are sure that the
+                // allocated size is less than the capacity.
+                let _ = script_cache
+                    .put_with_weight(key, ScriptWrapper::new(new_script, allocated_size))
+                    .unwrap_or_else(|_| None);
+            } else {
+                eprintln!(
+                    "Script cache is too small to hold module with size {}",
+                    allocated_size
+                );
+            }
         }
         Ok(verified_script)
     }
diff --git a/crates/types/src/module.rs b/crates/types/src/module.rs
index e2b02201..7ab5f63a 100644
--- a/crates/types/src/module.rs
+++ b/crates/types/src/module.rs
@@ -58,7 +58,7 @@ impl ModuleBundle {
 
     pub fn singleton(code: Vec<u8>) -> Self {
         Self {
-            codes: vec![Module::new(code.clone())],
+            codes: vec![Module::new(code)],
         }
     }
 
diff --git a/precompile/modules/initia_stdlib/sources/bigdecimal.move b/precompile/modules/initia_stdlib/sources/bigdecimal.move
index 52fd5b23..e52a5c13 100644
--- a/precompile/modules/initia_stdlib/sources/bigdecimal.move
+++ b/precompile/modules/initia_stdlib/sources/bigdecimal.move
@@ -117,6 +117,11 @@ module initia_std::bigdecimal {
     }
 
     public fun rev(num: BigDecimal): BigDecimal {
+        assert!(
+            !biguint::is_zero(num.scaled),
+            error::invalid_argument(EDIVISION_BY_ZERO)
+        );
+
         let fractional = f();
         BigDecimal {
             scaled: biguint::div(biguint::mul(fractional, fractional), num.scaled)
@@ -618,6 +623,13 @@ module initia_std::bigdecimal {
         div_by_u256(num1, 0);
     }
 
+    #[test]
+    #[expected_failure(abort_code = 0x10065, location = Self)]
+    fun test_bigdecimal_rev_zero() {
+        let num = zero();
+        rev(num);
+    }
+
     #[test]
     fun test_bigdecimal_scaled_le_bytes() {
         let num1 = from_ratio(biguint::from_u64(1), biguint::from_u64(3));
diff --git a/precompile/modules/initia_stdlib/sources/crypto/ed25519.move b/precompile/modules/initia_stdlib/sources/crypto/ed25519.move
index 021ac445..04e07716 100644
--- a/precompile/modules/initia_stdlib/sources/crypto/ed25519.move
+++ b/precompile/modules/initia_stdlib/sources/crypto/ed25519.move
@@ -44,7 +44,7 @@ module initia_std::ed25519 {
     public fun public_key_from_bytes(bytes: vector<u8>): PublicKey {
         assert!(
             std::vector::length(&bytes) == PUBLIC_KEY_SIZE,
-            std::error::invalid_argument(PUBLIC_KEY_SIZE)
+            std::error::invalid_argument(E_WRONG_PUBKEY_SIZE)
         );
         PublicKey { bytes }
     }
diff --git a/precompile/modules/initia_stdlib/sources/crypto/secp256k1.move b/precompile/modules/initia_stdlib/sources/crypto/secp256k1.move
index a9efb993..f963a061 100644
--- a/precompile/modules/initia_stdlib/sources/crypto/secp256k1.move
+++ b/precompile/modules/initia_stdlib/sources/crypto/secp256k1.move
@@ -204,9 +204,8 @@ module initia_std::secp256k1 {
 
         // Test with an incorrect signature
         let invalid_sig_bytes = sig_bytes;
-        *std::vector::borrow_mut(&mut invalid_sig_bytes, 0) = *std::vector::borrow(
-            &invalid_sig_bytes, 0
-        ) ^ 0x1; // Corrupt the signature
+        *std::vector::borrow_mut(&mut invalid_sig_bytes, 0) =
+            *std::vector::borrow(&invalid_sig_bytes, 0) ^ 0x1; // Corrupt the signature
         let invalid_sig = ecdsa_signature_from_bytes(invalid_sig_bytes);
         assert!(!verify(msg, &pk, &invalid_sig), 3);
     }
diff --git a/precompile/modules/initia_stdlib/sources/minitswap.move b/precompile/modules/initia_stdlib/sources/minitswap.move
index a780fdf8..a6cc62ae 100644
--- a/precompile/modules/initia_stdlib/sources/minitswap.move
+++ b/precompile/modules/initia_stdlib/sources/minitswap.move
@@ -449,11 +449,12 @@ module initia_std::minitswap {
         base_metadata: Object<Metadata>, quote_metadata: Object<Metadata>
     ): BigDecimal acquires ModuleStore, VirtualPool {
         let is_init_quote = is_init_metadata(quote_metadata);
-        let ibc_op_init_metadata = if (is_init_quote) {
-            base_metadata
-        } else {
-            quote_metadata
-        };
+        let ibc_op_init_metadata =
+            if (is_init_quote) {
+                base_metadata
+            } else {
+                quote_metadata
+            };
 
         let virtual_pool_exists = virtual_pool_exists(ibc_op_init_metadata);
 
@@ -1188,10 +1189,10 @@ module initia_std::minitswap {
                     - ibc_op_init_delta;
 
                 pool.virtual_init_balance = pool.virtual_init_balance + net_init_delta;
-                pool.virtual_ibc_op_init_balance = pool.virtual_ibc_op_init_balance
-                    + net_ibc_op_init_delta;
-                pool.peg_keeper_owned_ibc_op_init_balance = pool.peg_keeper_owned_ibc_op_init_balance
-                    + net_ibc_op_init_delta;
+                pool.virtual_ibc_op_init_balance =
+                    pool.virtual_ibc_op_init_balance + net_ibc_op_init_delta;
+                pool.peg_keeper_owned_ibc_op_init_balance =
+                    pool.peg_keeper_owned_ibc_op_init_balance + net_ibc_op_init_delta;
                 0
             } else {
                 /*
@@ -1214,10 +1215,10 @@ module initia_std::minitswap {
                 // pool.ibc_op_init_pool_amount = pool.pool_size;
                 pool.virtual_init_balance = pool.virtual_init_balance
                     + init_swap_amount;
-                pool.virtual_ibc_op_init_balance = pool.virtual_ibc_op_init_balance
-                    + ibc_op_init_swap_amount;
-                pool.peg_keeper_owned_ibc_op_init_balance = pool.peg_keeper_owned_ibc_op_init_balance
-                    + ibc_op_init_swap_amount;
+                pool.virtual_ibc_op_init_balance =
+                    pool.virtual_ibc_op_init_balance + ibc_op_init_swap_amount;
+                pool.peg_keeper_owned_ibc_op_init_balance =
+                    pool.peg_keeper_owned_ibc_op_init_balance + ibc_op_init_swap_amount;
 
                 // 2. change pool size
                 pool.init_pool_amount = new_pool_size;
@@ -1233,18 +1234,18 @@ module initia_std::minitswap {
                         pool.pool_size,
                         pool.ann
                     );
-                pool.ibc_op_init_pool_amount = pool.ibc_op_init_pool_amount
-                    + ibc_op_init_swap_amount;
+                pool.ibc_op_init_pool_amount =
+                    pool.ibc_op_init_pool_amount + ibc_op_init_swap_amount;
                 pool.init_pool_amount = pool.init_pool_amount - return_amount;
-                pool.virtual_ibc_op_init_balance = pool.virtual_ibc_op_init_balance
-                    - ibc_op_init_swap_amount;
-                pool.peg_keeper_owned_ibc_op_init_balance = pool.peg_keeper_owned_ibc_op_init_balance
-                    - ibc_op_init_swap_amount;
+                pool.virtual_ibc_op_init_balance =
+                    pool.virtual_ibc_op_init_balance - ibc_op_init_swap_amount;
+                pool.peg_keeper_owned_ibc_op_init_balance =
+                    pool.peg_keeper_owned_ibc_op_init_balance - ibc_op_init_swap_amount;
 
                 if (pool.virtual_init_balance < return_amount) {
                     let remain = return_amount - pool.virtual_init_balance;
-                    module_store.depositor_owned_init = module_store.depositor_owned_init
-                        + remain;
+                    module_store.depositor_owned_init =
+                        module_store.depositor_owned_init + remain;
                     pool.virtual_init_balance = 0;
                     remain
                 } else {
@@ -1529,8 +1530,8 @@ module initia_std::minitswap {
         let pool_signer = object::generate_signer_for_extending(&pool.extend_ref);
 
         // update pegkeeper owned balance
-        pool.peg_keeper_owned_ibc_op_init_balance = pool.peg_keeper_owned_ibc_op_init_balance
-            - ibc_op_init_sent;
+        pool.peg_keeper_owned_ibc_op_init_balance =
+            pool.peg_keeper_owned_ibc_op_init_balance - ibc_op_init_sent;
 
         // transfer trigger fee
         primary_fungible_store::transfer(
@@ -1551,8 +1552,8 @@ module initia_std::minitswap {
 
         // update depositor owned init
         let in_house_arb_profit = leftover_amount - init_used;
-        module_store.depositor_owned_init = module_store.depositor_owned_init
-            + in_house_arb_profit;
+        module_store.depositor_owned_init =
+            module_store.depositor_owned_init + in_house_arb_profit;
 
         // emit event
         event::emit(
@@ -1652,8 +1653,8 @@ module initia_std::minitswap {
             };
 
         // update depositor owned init
-        module_store.depositor_owned_init = module_store.depositor_owned_init
-            + provide_amount;
+        module_store.depositor_owned_init =
+            module_store.depositor_owned_init + provide_amount;
 
         // deposit token to module
         let module_addr = object::address_from_extend_ref(&module_store.extend_ref);
@@ -1695,8 +1696,8 @@ module initia_std::minitswap {
             );
 
         // decrease depositor owned init
-        module_store.depositor_owned_init = module_store.depositor_owned_init
-            - withdraw_amount;
+        module_store.depositor_owned_init =
+            module_store.depositor_owned_init - withdraw_amount;
 
         // burn share token
         coin::burn(&module_store.burn_cap, share_token);
@@ -1907,8 +1908,8 @@ module initia_std::minitswap {
                 table_key::encode_u64(callback_id)
             );
         pool.virtual_init_balance = pool.virtual_init_balance + init_used;
-        pool.virtual_ibc_op_init_balance = pool.virtual_ibc_op_init_balance
-            + ibc_op_init_sent;
+        pool.virtual_ibc_op_init_balance =
+            pool.virtual_ibc_op_init_balance + ibc_op_init_sent;
 
         event::emit<RevertArbEvent>(
             RevertArbEvent {
@@ -2078,12 +2079,12 @@ module initia_std::minitswap {
                         pool.ann
                     );
                 pool.init_pool_amount = pool.init_pool_amount - depositor_return_amount;
-                pool.ibc_op_init_pool_amount = pool.ibc_op_init_pool_amount
-                    + total_fee_amount;
+                pool.ibc_op_init_pool_amount =
+                    pool.ibc_op_init_pool_amount + total_fee_amount;
 
                 // increase depositor amount
-                module_store.depositor_owned_init = module_store.depositor_owned_init
-                    + depositor_return_amount;
+                module_store.depositor_owned_init =
+                    module_store.depositor_owned_init + depositor_return_amount;
 
                 (
                     primary_fungible_store::withdraw(
@@ -2116,8 +2117,8 @@ module initia_std::minitswap {
                 let return_amount = return_amount - swap_fee_amount;
 
                 // increase depositor amount
-                module_store.depositor_owned_init = module_store.depositor_owned_init
-                    + swap_fee_amount;
+                module_store.depositor_owned_init =
+                    module_store.depositor_owned_init + swap_fee_amount;
 
                 (
                     primary_fungible_store::withdraw(
@@ -2139,13 +2140,13 @@ module initia_std::minitswap {
         let (peg_keeper_offer_amount, peg_keeper_return_amount) =
             calc_peg_keeper_swap(pool);
         pool.init_pool_amount = pool.init_pool_amount + peg_keeper_offer_amount;
-        pool.ibc_op_init_pool_amount = pool.ibc_op_init_pool_amount
-            - peg_keeper_return_amount;
+        pool.ibc_op_init_pool_amount =
+            pool.ibc_op_init_pool_amount - peg_keeper_return_amount;
         pool.virtual_init_balance = pool.virtual_init_balance + peg_keeper_offer_amount;
-        pool.virtual_ibc_op_init_balance = pool.virtual_ibc_op_init_balance
-            + peg_keeper_return_amount;
-        pool.peg_keeper_owned_ibc_op_init_balance = pool.peg_keeper_owned_ibc_op_init_balance
-            + peg_keeper_return_amount;
+        pool.virtual_ibc_op_init_balance =
+            pool.virtual_ibc_op_init_balance + peg_keeper_return_amount;
+        pool.peg_keeper_owned_ibc_op_init_balance =
+            pool.peg_keeper_owned_ibc_op_init_balance + peg_keeper_return_amount;
         pool.last_recovered_timestamp = timestamp;
 
         (peg_keeper_offer_amount, peg_keeper_return_amount)
@@ -2631,8 +2632,9 @@ module initia_std::minitswap {
             // D ** (n + 1) / (n ** n * prod) in our case, always n = 2
             let d_prod = d * d * d / 4 / init_amount / ibc_op_init_amount;
 
-            d = (ann * sum / A_PRECISION + d_prod * 2) * d
-                / ((ann - A_PRECISION) * d / A_PRECISION + 3 * d_prod);
+            d =
+                (ann * sum / A_PRECISION + d_prod * 2) * d
+                    / ((ann - A_PRECISION) * d / A_PRECISION + 3 * d_prod);
             if (d > d_prev) {
                 if (d - d_prev <= 1) break
             } else {
@@ -2960,8 +2962,8 @@ module initia_std::minitswap {
                 // retry while actual return amount is equal to return amount
                 let i = 0;
                 while (return_amount > actual_return_amount && i < 255) {
-                    return_amount_before_swap_fee = return_amount_before_swap_fee
-                        + return_diff;
+                    return_amount_before_swap_fee =
+                        return_amount_before_swap_fee + return_diff;
 
                     if (ibc_op_init_pool_amount - return_amount_before_swap_fee
                         < pool_size) {
@@ -2982,14 +2984,17 @@ module initia_std::minitswap {
                     );
 
                     // calculate arb fee
-                    arb_profit = if (return_amount > offer_amount) {
-                        return_amount_before_swap_fee - swap_fee_amount - offer_amount
-                    } else { 0 };
+                    arb_profit =
+                        if (return_amount > offer_amount) {
+                            return_amount_before_swap_fee - swap_fee_amount
+                                - offer_amount
+                        } else { 0 };
                     arb_fee_amount = bigdecimal::mul_by_u64_ceil(
                         module_store.arb_fee_rate, arb_profit
                     );
-                    actual_return_amount = return_amount_before_swap_fee
-                        - swap_fee_amount - arb_fee_amount;
+                    actual_return_amount =
+                        return_amount_before_swap_fee - swap_fee_amount
+                            - arb_fee_amount;
                     if (actual_return_amount >= return_amount) break;
 
                     return_diff = return_amount - actual_return_amount;
diff --git a/precompile/modules/initia_stdlib/sources/multisig.move b/precompile/modules/initia_stdlib/sources/multisig.move
index 6d9396c7..f2546cd8 100644
--- a/precompile/modules/initia_stdlib/sources/multisig.move
+++ b/precompile/modules/initia_stdlib/sources/multisig.move
@@ -487,13 +487,13 @@ module initia_std::multisig {
         let expired_height =
             if (option::is_some(&max_period.height)) {
                 let max_voting_period_height = *option::borrow(&max_period.height);
-                (max_voting_period_height + proposal_height) >= height
+                height >= (max_voting_period_height + proposal_height)
             } else { false };
 
         let expired_timestamp =
             if (option::is_some(&max_period.timestamp)) {
                 let max_voting_period_timestamp = *option::borrow(&max_period.timestamp);
-                (max_voting_period_timestamp + proposal_timestamp) >= timestamp
+                timestamp >= (max_voting_period_timestamp + proposal_timestamp)
             } else { false };
 
         expired_height || expired_timestamp
diff --git a/precompile/modules/initia_stdlib/sources/stableswap.move b/precompile/modules/initia_stdlib/sources/stableswap.move
index cec6da65..bd671b0b 100644
--- a/precompile/modules/initia_stdlib/sources/stableswap.move
+++ b/precompile/modules/initia_stdlib/sources/stableswap.move
@@ -813,9 +813,10 @@ module initia_std::stableswap {
         let fee_amounts: vector<u64> = vector[];
         let i = 0;
         while (i < n) {
-            let (amount, fee) = if (i == return_index) {
-                (return_amount, fee)
-            } else { (0, 0) };
+            let (amount, fee) =
+                if (i == return_index) {
+                    (return_amount, fee)
+                } else { (0, 0) };
             vector::push_back(&mut coin_amounts, amount);
             vector::push_back(&mut fee_amounts, fee);
             i = i + 1;
@@ -1019,8 +1020,9 @@ module initia_std::stableswap {
                 j = j + 1;
             };
 
-            d = (ann * sum / A_PRECISION + d_prod * n) * d
-                / ((ann - A_PRECISION) * d / A_PRECISION + (n + 1) * d_prod);
+            d =
+                (ann * sum / A_PRECISION + d_prod * n) * d
+                    / ((ann - A_PRECISION) * d / A_PRECISION + (n + 1) * d_prod);
             if (d > d_prev) {
                 if (d - d_prev <= 1) break
             } else {
@@ -1163,8 +1165,9 @@ module initia_std::stableswap {
                 };
 
             let pool_amount = vector::borrow_mut(&mut pool_amounts_reduced, i);
-            *pool_amount = *pool_amount
-                - bigdecimal::mul_by_u64_truncate(withdraw_fee_rate, amount_diff);
+            *pool_amount =
+                *pool_amount
+                    - bigdecimal::mul_by_u64_truncate(withdraw_fee_rate, amount_diff);
             i = i + 1;
         };
 
diff --git a/precompile/modules/initia_stdlib/sources/table.move b/precompile/modules/initia_stdlib/sources/table.move
index 7b220c15..ae83218d 100644
--- a/precompile/modules/initia_stdlib/sources/table.move
+++ b/precompile/modules/initia_stdlib/sources/table.move
@@ -234,6 +234,19 @@ module initia_std::table {
         (key, &mut box.val)
     }
 
+    public fun to_simple_map<K: store + copy + drop, V: store + copy>(
+        table: &Table<K, V>
+    ): std::simple_map::SimpleMap<K, V> {
+        let map = std::simple_map::new();
+        let iter = iter(table, option::none(), option::none(), 1);
+        while (prepare(iter)) {
+            let (key, value) = next(iter);
+            std::simple_map::add(&mut map, key, *value);
+        };
+
+        map
+    }
+
     // ======================================================================================================
     // Internal API
 
diff --git a/precompile/modules/minitia_stdlib/sources/bigdecimal.move b/precompile/modules/minitia_stdlib/sources/bigdecimal.move
index ee53b632..191ad871 100644
--- a/precompile/modules/minitia_stdlib/sources/bigdecimal.move
+++ b/precompile/modules/minitia_stdlib/sources/bigdecimal.move
@@ -117,6 +117,11 @@ module minitia_std::bigdecimal {
     }
 
     public fun rev(num: BigDecimal): BigDecimal {
+        assert!(
+            !biguint::is_zero(num.scaled),
+            error::invalid_argument(EDIVISION_BY_ZERO)
+        );
+
         let fractional = f();
         BigDecimal {
             scaled: biguint::div(biguint::mul(fractional, fractional), num.scaled)
@@ -618,6 +623,13 @@ module minitia_std::bigdecimal {
         div_by_u256(num1, 0);
     }
 
+    #[test]
+    #[expected_failure(abort_code = 0x10065, location = Self)]
+    fun test_bigdecimal_rev_zero() {
+        let num = zero();
+        rev(num);
+    }
+
     #[test]
     fun test_bigdecimal_scaled_le_bytes() {
         let num1 = from_ratio(biguint::from_u64(1), biguint::from_u64(3));
diff --git a/precompile/modules/minitia_stdlib/sources/crypto/ed25519.move b/precompile/modules/minitia_stdlib/sources/crypto/ed25519.move
index c77f770f..f10d4130 100644
--- a/precompile/modules/minitia_stdlib/sources/crypto/ed25519.move
+++ b/precompile/modules/minitia_stdlib/sources/crypto/ed25519.move
@@ -44,7 +44,7 @@ module minitia_std::ed25519 {
     public fun public_key_from_bytes(bytes: vector<u8>): PublicKey {
         assert!(
             std::vector::length(&bytes) == PUBLIC_KEY_SIZE,
-            std::error::invalid_argument(PUBLIC_KEY_SIZE)
+            std::error::invalid_argument(E_WRONG_PUBKEY_SIZE)
         );
         PublicKey { bytes }
     }
diff --git a/precompile/modules/minitia_stdlib/sources/crypto/secp256k1.move b/precompile/modules/minitia_stdlib/sources/crypto/secp256k1.move
index a9f97939..bec58acb 100644
--- a/precompile/modules/minitia_stdlib/sources/crypto/secp256k1.move
+++ b/precompile/modules/minitia_stdlib/sources/crypto/secp256k1.move
@@ -204,9 +204,8 @@ module minitia_std::secp256k1 {
 
         // Test with an incorrect signature
         let invalid_sig_bytes = sig_bytes;
-        *std::vector::borrow_mut(&mut invalid_sig_bytes, 0) = *std::vector::borrow(
-            &invalid_sig_bytes, 0
-        ) ^ 0x1; // Corrupt the signature
+        *std::vector::borrow_mut(&mut invalid_sig_bytes, 0) =
+            *std::vector::borrow(&invalid_sig_bytes, 0) ^ 0x1; // Corrupt the signature
         let invalid_sig = ecdsa_signature_from_bytes(invalid_sig_bytes);
         assert!(!verify(msg, &pk, &invalid_sig), 3);
     }
diff --git a/precompile/modules/minitia_stdlib/sources/multisig.move b/precompile/modules/minitia_stdlib/sources/multisig.move
index 10d1d1e3..62e64677 100644
--- a/precompile/modules/minitia_stdlib/sources/multisig.move
+++ b/precompile/modules/minitia_stdlib/sources/multisig.move
@@ -487,13 +487,13 @@ module minitia_std::multisig {
         let expired_height =
             if (option::is_some(&max_period.height)) {
                 let max_voting_period_height = *option::borrow(&max_period.height);
-                (max_voting_period_height + proposal_height) >= height
+                height >= (max_voting_period_height + proposal_height)
             } else { false };
 
         let expired_timestamp =
             if (option::is_some(&max_period.timestamp)) {
                 let max_voting_period_timestamp = *option::borrow(&max_period.timestamp);
-                (max_voting_period_timestamp + proposal_timestamp) >= timestamp
+                timestamp >= (max_voting_period_timestamp + proposal_timestamp)
             } else { false };
 
         expired_height || expired_timestamp
diff --git a/precompile/modules/minitia_stdlib/sources/table.move b/precompile/modules/minitia_stdlib/sources/table.move
index 32f1df92..ab4aef37 100644
--- a/precompile/modules/minitia_stdlib/sources/table.move
+++ b/precompile/modules/minitia_stdlib/sources/table.move
@@ -234,6 +234,19 @@ module minitia_std::table {
         (key, &mut box.val)
     }
 
+    public fun to_simple_map<K: store + copy + drop, V: store + copy>(
+        table: &Table<K, V>
+    ): std::simple_map::SimpleMap<K, V> {
+        let map = std::simple_map::new();
+        let iter = iter(table, option::none(), option::none(), 1);
+        while (prepare(iter)) {
+            let (key, value) = next(iter);
+            std::simple_map::add(&mut map, key, *value);
+        };
+
+        map
+    }
+
     // ======================================================================================================
     // Internal API