diff --git a/framework/src/binding/store/array.rs b/framework/src/binding/store/array.rs
index bc97bcfea..379a7038b 100644
--- a/framework/src/binding/store/array.rs
+++ b/framework/src/binding/store/array.rs
@@ -41,7 +41,7 @@ impl<S: ServiceState, E: FixedCodec> DefaultStoreArray<S, E> {
         }
     }
 
-    fn get_(&self, index: u32) -> ProtocolResult<Option<E>> {
+    fn inner_get(&self, index: u32) -> ProtocolResult<Option<E>> {
         if let Some(k) = self.keys.inner.get(index as usize) {
             self.state.borrow().get(k)?.map_or_else(
                 || {
@@ -58,7 +58,7 @@ impl<S: ServiceState, E: FixedCodec> DefaultStoreArray<S, E> {
 
     // TODO(@zhounan): Atomicity of insert(k, v) and insert self.keys to
     // ServiceState is not guaranteed for now That must be settled soon after.
-    fn push_(&mut self, elm: E) -> ProtocolResult<()> {
+    fn inner_push(&mut self, elm: E) -> ProtocolResult<()> {
         let key = Hash::digest(elm.encode_fixed()?);
 
         self.keys.inner.push(key.clone());
@@ -71,7 +71,7 @@ impl<S: ServiceState, E: FixedCodec> DefaultStoreArray<S, E> {
 
     // TODO(@zhounan): Atomicity of insert(k, v) and insert self.keys to
     // ServiceState is not guaranteed for now That must be settled soon after.
-    fn remove_(&mut self, index: u32) -> ProtocolResult<()> {
+    fn inner_remove(&mut self, index: u32) -> ProtocolResult<()> {
         let key = self.keys.inner.remove(index as usize);
         self.state
             .borrow_mut()
@@ -83,17 +83,17 @@ impl<S: ServiceState, E: FixedCodec> DefaultStoreArray<S, E> {
 
 impl<S: ServiceState, E: FixedCodec> StoreArray<E> for DefaultStoreArray<S, E> {
     fn get(&self, index: u32) -> Option<E> {
-        self.get_(index)
+        self.inner_get(index)
             .unwrap_or_else(|e| panic!("StoreArray get value failed: {}", e))
     }
 
     fn push(&mut self, elm: E) {
-        self.push_(elm)
+        self.inner_push(elm)
             .unwrap_or_else(|e| panic!("StoreArray push value failed: {}", e));
     }
 
     fn remove(&mut self, index: u32) {
-        self.remove_(index)
+        self.inner_remove(index)
             .unwrap_or_else(|e| panic!("StoreArray remove value failed: {}", e));
     }
 
diff --git a/framework/src/binding/store/map.rs b/framework/src/binding/store/map.rs
index e805fe96c..4d4c52dfb 100644
--- a/framework/src/binding/store/map.rs
+++ b/framework/src/binding/store/map.rs
@@ -51,7 +51,7 @@ impl<S: 'static + ServiceState, K: 'static + FixedCodec + PartialEq, V: 'static
         Ok(Hash::digest(Bytes::from(name_bytes)))
     }
 
-    fn get_(&self, key: &K) -> ProtocolResult<Option<V>> {
+    fn inner_get(&self, key: &K) -> ProtocolResult<Option<V>> {
         if self.keys.inner.contains(key) {
             let mk = self.get_map_key(key)?;
             self.state.borrow().get(&mk)?.map_or_else(
@@ -69,7 +69,7 @@ impl<S: 'static + ServiceState, K: 'static + FixedCodec + PartialEq, V: 'static
 
     // TODO(@zhounan): Atomicity of insert(k, v) and insert self.keys to
     // ServiceState is not guaranteed for now That must be settled soon after.
-    fn insert_(&mut self, key: K, value: V) -> ProtocolResult<()> {
+    fn inner_insert(&mut self, key: K, value: V) -> ProtocolResult<()> {
         let mk = self.get_map_key(&key)?;
 
         if !self.contains(&key) {
@@ -84,9 +84,9 @@ impl<S: 'static + ServiceState, K: 'static + FixedCodec + PartialEq, V: 'static
 
     // TODO(@zhounan): Atomicity of insert(k, v) and insert self.keys to
     // ServiceState is not guaranteed for now That must be settled soon after.
-    fn remove_(&mut self, key: &K) -> ProtocolResult<Option<V>> {
+    fn inner_remove(&mut self, key: &K) -> ProtocolResult<Option<V>> {
         if self.contains(key) {
-            let value: V = self.get_(key)?.expect("value should be existed");
+            let value: V = self.inner_get(key)?.expect("value should be existed");
             self.keys.inner.remove_item(key);
             self.state
                 .borrow_mut()
@@ -107,17 +107,17 @@ impl<S: 'static + ServiceState, K: 'static + FixedCodec + PartialEq, V: 'static
     StoreMap<K, V> for DefaultStoreMap<S, K, V>
 {
     fn get(&self, key: &K) -> Option<V> {
-        self.get_(key)
+        self.inner_get(key)
             .unwrap_or_else(|e| panic!("StoreMap get failed: {}", e))
     }
 
     fn insert(&mut self, key: K, value: V) {
-        self.insert_(key, value)
+        self.inner_insert(key, value)
             .unwrap_or_else(|e| panic!("StoreMap insert failed: {}", e));
     }
 
     fn remove(&mut self, key: &K) -> Option<V> {
-        self.remove_(key)
+        self.inner_remove(key)
             .unwrap_or_else(|e| panic!("StoreMap remove failed: {}", e))
     }
 
diff --git a/framework/src/binding/store/primitive.rs b/framework/src/binding/store/primitive.rs
index ba7caf35b..7f389afb0 100644
--- a/framework/src/binding/store/primitive.rs
+++ b/framework/src/binding/store/primitive.rs
@@ -7,8 +7,6 @@ use protocol::traits::{ServiceState, StoreBool, StoreString, StoreUint64};
 use protocol::types::Hash;
 use protocol::ProtocolResult;
 
-use crate::binding::store::StoreError;
-
 pub struct DefaultStoreBool<S: ServiceState> {
     state: Rc<RefCell<S>>,
     key:   Hash,
@@ -22,7 +20,7 @@ impl<S: ServiceState> DefaultStoreBool<S> {
         }
     }
 
-    fn get_(&self) -> ProtocolResult<bool> {
+    fn inner_get(&self) -> ProtocolResult<bool> {
         let b: Option<bool> = self.state.borrow().get(&self.key)?;
 
         match b {
@@ -34,7 +32,7 @@ impl<S: ServiceState> DefaultStoreBool<S> {
         }
     }
 
-    fn set_(&mut self, b: bool) -> ProtocolResult<()> {
+    fn inner_set(&mut self, b: bool) -> ProtocolResult<()> {
         self.state.borrow_mut().insert(self.key.clone(), b)?;
         Ok(())
     }
@@ -42,12 +40,12 @@ impl<S: ServiceState> DefaultStoreBool<S> {
 
 impl<S: ServiceState> StoreBool for DefaultStoreBool<S> {
     fn get(&self) -> bool {
-        self.get_()
+        self.inner_get()
             .unwrap_or_else(|e| panic!("StoreBool get failed: {}", e))
     }
 
     fn set(&mut self, b: bool) {
-        self.set_(b)
+        self.inner_set(b)
             .unwrap_or_else(|e| panic!("StoreBool set failed: {}", e));
     }
 }
@@ -65,144 +63,157 @@ impl<S: ServiceState> DefaultStoreUint64<S> {
         }
     }
 
-    fn get_(&self) -> ProtocolResult<u64> {
-        let u: Option<u64> = self.state.borrow().get(&self.key)?;
+    fn inner_get(&self) -> u64 {
+        let u: Option<u64> = self
+            .state
+            .borrow()
+            .get(&self.key)
+            .unwrap_or_else(|e| panic!("StoreUint64 get failed: {}", e));
 
         match u {
-            Some(v) => Ok(v),
+            Some(v) => v,
             None => {
-                self.state.borrow_mut().insert(self.key.clone(), 0u64)?;
-                Ok(0)
+                self.state
+                    .borrow_mut()
+                    .insert(self.key.clone(), 0u64)
+                    .unwrap_or_else(|e| panic!("StoreUint64 get failed: {}", e));
+                0
             }
         }
     }
 
-    fn set_(&mut self, val: u64) -> ProtocolResult<()> {
-        self.state.borrow_mut().insert(self.key.clone(), val)?;
-        Ok(())
+    fn inner_set(&mut self, val: u64) {
+        self.state
+            .borrow_mut()
+            .insert(self.key.clone(), val)
+            .unwrap_or_else(|e| panic!("StoreUint64 set failed: {}", e));
     }
 
     // Add val with self
     // And set the result back to self
-    fn add_(&mut self, val: u64) -> ProtocolResult<()> {
-        let sv = self.get_()?;
+    fn inner_add(&mut self, val: u64) -> bool {
+        let sv = self.inner_get();
 
         match val.overflowing_add(sv) {
-            (sum, false) => self.set_(sum),
-            _ => Err(StoreError::Overflow.into()),
+            (sum, false) => {
+                self.inner_set(sum);
+                false
+            }
+            _ => true,
         }
     }
 
     // Self minus val
     // And set the result back to self
-    fn sub_(&mut self, val: u64) -> ProtocolResult<()> {
-        let sv = self.get_()?;
+    fn inner_sub(&mut self, val: u64) -> bool {
+        let sv = self.inner_get();
 
         if sv >= val {
-            self.set_(sv - val)
+            self.inner_set(sv - val);
+            false
         } else {
-            Err(StoreError::Overflow.into())
+            true
         }
     }
 
     // Multiply val with self
     // And set the result back to self
-    fn mul_(&mut self, val: u64) -> ProtocolResult<()> {
-        let sv = self.get_()?;
+    fn inner_mul(&mut self, val: u64) -> bool {
+        let sv = self.inner_get();
 
         match val.overflowing_mul(sv) {
-            (mul, false) => self.set_(mul),
-            _ => Err(StoreError::Overflow.into()),
+            (mul, false) => {
+                self.inner_set(mul);
+                false
+            }
+            _ => true,
         }
     }
 
     // Power of self
     // And set the result back to self
-    fn pow_(&mut self, val: u32) -> ProtocolResult<()> {
-        let sv = self.get_()?;
+    fn inner_pow(&mut self, val: u32) -> bool {
+        let sv = self.inner_get();
 
         match sv.overflowing_pow(val) {
-            (pow, false) => self.set_(pow),
-            _ => Err(StoreError::Overflow.into()),
+            (pow, false) => {
+                self.inner_set(pow);
+                false
+            }
+            _ => true,
         }
     }
 
     // Self divided by val
     // And set the result back to self
-    fn div_(&mut self, val: u64) -> ProtocolResult<()> {
-        let sv = self.get_()?;
+    fn inner_div(&mut self, val: u64) -> bool {
+        let sv = self.inner_get();
 
         if let 0 = val {
-            Err(StoreError::Overflow.into())
+            true
         } else {
-            self.set_(sv / val)
+            self.inner_set(sv / val);
+            false
         }
     }
 
     // Remainder of self
     // And set the result back to self
-    fn rem_(&mut self, val: u64) -> ProtocolResult<()> {
-        let sv = self.get_()?;
+    fn inner_rem(&mut self, val: u64) -> bool {
+        let sv = self.inner_get();
 
         if let 0 = val {
-            Err(StoreError::Overflow.into())
+            true
         } else {
-            self.set_(sv % val)
+            self.inner_set(sv % val);
+            false
         }
     }
 }
 
 impl<S: ServiceState> StoreUint64 for DefaultStoreUint64<S> {
     fn get(&self) -> u64 {
-        self.get_()
-            .unwrap_or_else(|e| panic!("StoreUint64 get failed: {}", e))
+        self.inner_get()
     }
 
     fn set(&mut self, val: u64) {
-        self.set_(val)
-            .unwrap_or_else(|e| panic!("StoreUint64 set failed: {}", e));
+        self.inner_set(val);
     }
 
     // Add val with self
     // And set the result back to self
-    fn add(&mut self, val: u64) {
-        self.add_(val)
-            .unwrap_or_else(|e| panic!("StoreUint64 add value failed: {}", e));
+    fn safe_add(&mut self, val: u64) -> bool {
+        self.inner_add(val)
     }
 
     // Self minus val
     // And set the result back to self
-    fn sub(&mut self, val: u64) {
-        self.sub_(val)
-            .unwrap_or_else(|e| panic!("StoreUint64 sub value failed: {}", e));
+    fn safe_sub(&mut self, val: u64) -> bool {
+        self.inner_sub(val)
     }
 
     // Multiply val with self
     // And set the result back to self
-    fn mul(&mut self, val: u64) {
-        self.mul_(val)
-            .unwrap_or_else(|e| panic!("StoreUint64 mul value failed: {}", e));
+    fn safe_mul(&mut self, val: u64) -> bool {
+        self.inner_mul(val)
     }
 
     // Power of self
     // And set the result back to self
-    fn pow(&mut self, val: u32) {
-        self.pow_(val)
-            .unwrap_or_else(|e| panic!("StoreUint64 pow value failed: {}", e));
+    fn safe_pow(&mut self, val: u32) -> bool {
+        self.inner_pow(val)
     }
 
     // Self divided by val
     // And set the result back to self
-    fn div(&mut self, val: u64) {
-        self.div_(val)
-            .unwrap_or_else(|e| panic!("StoreUint64 div value failed: {}", e));
+    fn safe_div(&mut self, val: u64) -> bool {
+        self.inner_div(val)
     }
 
     // Remainder of self
     // And set the result back to self
-    fn rem(&mut self, val: u64) {
-        self.rem_(val)
-            .unwrap_or_else(|e| panic!("StoreUint64 rem value failed: {}", e));
+    fn safe_rem(&mut self, val: u64) -> bool {
+        self.inner_rem(val)
     }
 }
 
@@ -219,14 +230,14 @@ impl<S: ServiceState> DefaultStoreString<S> {
         }
     }
 
-    fn set_(&mut self, val: &str) -> ProtocolResult<()> {
+    fn inner_set(&mut self, val: &str) -> ProtocolResult<()> {
         self.state
             .borrow_mut()
             .insert(self.key.clone(), val.to_string())?;
         Ok(())
     }
 
-    fn get_(&self) -> ProtocolResult<String> {
+    fn inner_get(&self) -> ProtocolResult<String> {
         let s: Option<String> = self.state.borrow().get(&self.key)?;
 
         match s {
@@ -240,28 +251,28 @@ impl<S: ServiceState> DefaultStoreString<S> {
         }
     }
 
-    fn len_(&self) -> ProtocolResult<u32> {
-        self.get_().map(|s| s.len() as u32)
+    fn inner_len(&self) -> ProtocolResult<u32> {
+        self.inner_get().map(|s| s.len() as u32)
     }
 
     fn is_empty_(&self) -> ProtocolResult<bool> {
-        self.get_().map(|s| s.is_empty())
+        self.inner_get().map(|s| s.is_empty())
     }
 }
 
 impl<S: ServiceState> StoreString for DefaultStoreString<S> {
     fn get(&self) -> String {
-        self.get_()
+        self.inner_get()
             .unwrap_or_else(|e| panic!("StoreString get failed: {}", e))
     }
 
     fn set(&mut self, val: &str) {
-        self.set_(val)
+        self.inner_set(val)
             .unwrap_or_else(|e| panic!("StoreString set failed: {}", e));
     }
 
     fn len(&self) -> u32 {
-        self.len_()
+        self.inner_len()
             .unwrap_or_else(|e| panic!("StoreString get length failed: {}", e))
     }
 
diff --git a/framework/src/binding/tests/store.rs b/framework/src/binding/tests/store.rs
index ef5f73b6d..6d55161d1 100644
--- a/framework/src/binding/tests/store.rs
+++ b/framework/src/binding/tests/store.rs
@@ -38,22 +38,22 @@ fn test_default_store_uint64() {
     su.set(8u64);
     assert_eq!(su.get(), 8u64);
 
-    su.add(12u64);
+    assert_eq!(su.safe_add(12u64), false);
     assert_eq!(su.get(), 20u64);
 
-    su.sub(10u64);
+    assert_eq!(su.safe_sub(10u64), false);
     assert_eq!(su.get(), 10u64);
 
-    su.mul(8u64);
+    assert_eq!(su.safe_mul(8u64), false);
     assert_eq!(su.get(), 80u64);
 
-    su.div(10u64);
+    assert_eq!(su.safe_div(10u64), false);
     assert_eq!(su.get(), 8u64);
 
-    su.pow(2u32);
+    assert_eq!(su.safe_pow(2u32), false);
     assert_eq!(su.get(), 64u64);
 
-    su.rem(5u64);
+    assert_eq!(su.safe_rem(5u64), false);
     assert_eq!(su.get(), 4u64);
 }
 
diff --git a/protocol/src/traits/binding.rs b/protocol/src/traits/binding.rs
index d9f1ed6a0..e2a9349da 100644
--- a/protocol/src/traits/binding.rs
+++ b/protocol/src/traits/binding.rs
@@ -234,27 +234,27 @@ pub trait StoreUint64 {
 
     // Add val with self
     // And set the result back to self
-    fn add(&mut self, val: u64);
+    fn safe_add(&mut self, val: u64) -> bool;
 
     // Self minus val
     // And set the result back to self
-    fn sub(&mut self, val: u64);
+    fn safe_sub(&mut self, val: u64) -> bool;
 
     // Multiply val with self
     // And set the result back to self
-    fn mul(&mut self, val: u64);
+    fn safe_mul(&mut self, val: u64) -> bool;
 
     // Power of self
     // And set the result back to self
-    fn pow(&mut self, val: u32);
+    fn safe_pow(&mut self, val: u32) -> bool;
 
     // Self divided by val
     // And set the result back to self
-    fn div(&mut self, val: u64);
+    fn safe_div(&mut self, val: u64) -> bool;
 
     // Remainder of self
     // And set the result back to self
-    fn rem(&mut self, val: u64);
+    fn safe_rem(&mut self, val: u64) -> bool;
 }
 
 pub trait StoreString {