diff --git a/examples/contract.rs b/examples/contract.rs
index cfaefa8..15c0816 100644
--- a/examples/contract.rs
+++ b/examples/contract.rs
@@ -16,13 +16,6 @@ impl ContractInterface for Contract {
         unimplemented!()
     }
 
-    fn validate_delta(
-        _parameters: Parameters<'static>,
-        _delta: StateDelta<'static>,
-    ) -> Result<bool, ContractError> {
-        unimplemented!()
-    }
-
     fn update_state(
         _parameters: Parameters<'static>,
         _state: State<'static>,
diff --git a/rust-macros/src/contract_impl.rs b/rust-macros/src/contract_impl.rs
index 6e2a774..439bd8f 100644
--- a/rust-macros/src/contract_impl.rs
+++ b/rust-macros/src/contract_impl.rs
@@ -352,13 +352,6 @@ impl ImplTrait {
                     ::freenet_stdlib::typed_contract::inner_validate_state::<#type_name>(parameters, state, related)
                 }
 
-                fn validate_delta(
-                    parameters: ::freenet_stdlib::prelude::Parameters<'static>,
-                    delta: ::freenet_stdlib::prelude::StateDelta<'static>,
-                ) -> ::core::result::Result<bool, ::freenet_stdlib::prelude::ContractError> {
-                    ::freenet_stdlib::typed_contract::inner_validate_delta::<#type_name>(parameters, delta)
-                }
-
                 fn update_state(
                     parameters: ::freenet_stdlib::prelude::Parameters<'static>,
                     state: ::freenet_stdlib::prelude::State<'static>,
@@ -415,17 +408,6 @@ impl ImplTrait {
             }
         });
 
-        let validate_delta_impl = self.children.iter().map(|child| {
-            quote! {
-                if !::freenet_stdlib::contract_composition::from_bytes::inner_validate_delta::<
-                    #type_name,
-                    #child,
-                >(parameters.clone(), delta.clone())? {
-                    return ::core::result::Result::Ok(false);
-                }
-            }
-        });
-
         let update_state_impl = self.children.iter().map(|child| {
             quote! {{
                 let modification = ::freenet_stdlib::contract_composition::from_bytes::inner_update_state::<
@@ -454,14 +436,6 @@ impl ImplTrait {
                     ::core::result::Result::Ok(::freenet_stdlib::prelude::ValidateResult::Valid)
                 }
 
-                fn validate_delta(
-                    parameters: ::freenet_stdlib::prelude::Parameters<'static>,
-                    delta: ::freenet_stdlib::prelude::StateDelta<'static>,
-                ) -> ::core::result::Result<bool, ::freenet_stdlib::prelude::ContractError> {
-                    #(#validate_delta_impl)*
-                    ::core::result::Result::Ok(true)
-                }
-
                 fn update_state(
                     parameters: ::freenet_stdlib::prelude::Parameters<'static>,
                     state: ::freenet_stdlib::prelude::State<'static>,
@@ -513,13 +487,11 @@ impl ImplTrait {
 
     fn gen_extern_functions(&self) -> TokenStream {
         let validate_state_fn = self.gen_validate_state_fn();
-        let validate_delta_fn = self.gen_validate_delta_fn();
         let update_fn = self.gen_update_state_fn();
         let summarize_fn = self.gen_summarize_state_fn();
         let get_delta_fn = self.gen_get_state_delta();
         quote! {
             #validate_state_fn
-            #validate_delta_fn
             #update_fn
             #summarize_fn
             #get_delta_fn
@@ -538,18 +510,6 @@ impl ImplTrait {
         }
     }
 
-    fn gen_validate_delta_fn(&self) -> TokenStream {
-        let type_name = &self.type_name;
-        let ret = self.ffi_ret_type();
-        quote! {
-            #[no_mangle]
-            #[cfg(feature = "freenet-main-contract")]
-            pub extern "C" fn validate_delta(parameters: i64, delta: i64) -> #ret {
-                ::freenet_stdlib::memory::wasm_interface::inner_validate_delta::<#type_name>(parameters, delta)
-            }
-        }
-    }
-
     fn gen_update_state_fn(&self) -> TokenStream {
         let type_name = &self.type_name;
         let ret = self.ffi_ret_type();
diff --git a/rust/src/contract_composition.rs b/rust/src/contract_composition.rs
index f73902a..3779666 100644
--- a/rust/src/contract_composition.rs
+++ b/rust/src/contract_composition.rs
@@ -36,14 +36,6 @@ pub trait ContractComponent: std::any::Any + Sized {
         Child: ContractComponent,
         Self::Context: for<'x> From<&'x Ctx>;
 
-    /// Corresponds to ContractInterface `validate_delta`
-    fn verify_delta<Child>(
-        parameters: &Self::Parameters,
-        delta: &Self::Delta,
-    ) -> Result<bool, ContractError>
-    where
-        Child: ContractComponent;
-
     /// Corresponds to ContractInterface `update_state`
     fn merge(
         &mut self,
@@ -274,34 +266,6 @@ pub mod from_bytes {
         Ok(ValidateResult::Valid)
     }
 
-    pub fn inner_validate_delta<T, Child>(
-        parameters: Parameters<'static>,
-        delta: StateDelta<'static>,
-    ) -> Result<bool, ContractError>
-    where
-        T: ContractComponent + EncodingAdapter,
-        <T as EncodingAdapter>::Parameters: Into<<T as ContractComponent>::Parameters>,
-        <T as EncodingAdapter>::Delta: Into<<T as ContractComponent>::Delta>,
-        ContractError: From<
-            <<T as EncodingAdapter>::ParametersEncoder as Encoder<
-                <T as EncodingAdapter>::Parameters,
-            >>::Error,
-        >,
-        ContractError: From<
-            <<T as EncodingAdapter>::DeltaEncoder as Encoder<<T as EncodingAdapter>::Delta>>::Error,
-        >,
-        Child: ContractComponent,
-        <Child as ContractComponent>::Parameters:
-            for<'x> From<&'x <T as ContractComponent>::Parameters>,
-        <Child as ContractComponent>::Delta: for<'x> From<&'x <T as ContractComponent>::Delta>,
-    {
-        let typed_params =
-            <<T as EncodingAdapter>::ParametersEncoder>::deserialize(parameters.as_ref())?.into();
-        let typed_delta =
-            <<T as EncodingAdapter>::DeltaEncoder>::deserialize(delta.as_ref())?.into();
-        <T as ContractComponent>::verify_delta::<Child>(&typed_params, &typed_delta)
-    }
-
     pub fn inner_update_state<T, Child>(
         parameters: Parameters<'static>,
         state: State<'static>,
diff --git a/rust/src/contract_interface.rs b/rust/src/contract_interface.rs
index 47e47ca..e4f8807 100644
--- a/rust/src/contract_interface.rs
+++ b/rust/src/contract_interface.rs
@@ -401,13 +401,6 @@ impl<'a> TryFromFbs<&FbsUpdateData<'a>> for UpdateData<'a> {
 ///         Ok(ValidateResult::Valid)
 ///     }
 ///
-///     fn validate_delta(
-///         _parameters: Parameters<'static>,
-///         _delta: StateDelta<'static>
-///     ) -> Result<bool, ContractError> {
-///         Ok(true)
-///     }
-///
 ///     fn update_state(
 ///         _parameters: Parameters<'static>,
 ///         state: State<'static>,
@@ -451,13 +444,6 @@ pub trait ContractInterface {
         related: RelatedContracts<'static>,
     ) -> Result<ValidateResult, ContractError>;
 
-    /// Verify that a delta is valid if possible, returns false if and only delta is
-    /// definitely invalid, true otherwise.
-    fn validate_delta(
-        parameters: Parameters<'static>,
-        delta: StateDelta<'static>,
-    ) -> Result<bool, ContractError>;
-
     /// Update the state to account for the new data
     fn update_state(
         parameters: Parameters<'static>,
@@ -1386,26 +1372,6 @@ pub(crate) mod wasm_interface {
             }
         }
 
-        pub unsafe fn unwrap_validate_delta_res(
-            self,
-            mem: WasmLinearMem,
-        ) -> Result<bool, ContractError> {
-            #![allow(clippy::let_and_return)]
-            let kind = ResultKind::from(self.kind);
-            match kind {
-                ResultKind::ValidateDelta => {
-                    let ptr = crate::memory::buf::compute_ptr(self.ptr as *mut u8, &mem);
-                    let serialized = std::slice::from_raw_parts(ptr as *const u8, self.size as _);
-                    let value = bincode::deserialize(serialized)
-                        .map_err(|e| ContractError::Other(format!("{e}")))?;
-                    #[cfg(feature = "trace")]
-                    self.log_input(serialized, &value, ptr);
-                    value
-                }
-                _ => unreachable!(),
-            }
-        }
-
         pub unsafe fn unwrap_update_state(
             self,
             mem: WasmLinearMem,
@@ -1893,27 +1859,6 @@ pub mod encoding {
         typed_state.verify(typed_params, related_container)
     }
 
-    pub fn inner_validate_delta<T>(
-        parameters: Parameters<'static>,
-        delta: StateDelta<'static>,
-    ) -> Result<bool, ContractError>
-    where
-        T: EncodingAdapter + TypedContract,
-        ContractError: From<
-            <<T as EncodingAdapter>::ParametersEncoder as Encoder<
-                <T as EncodingAdapter>::Parameters,
-            >>::Error,
-        >,
-        ContractError: From<
-            <<T as EncodingAdapter>::DeltaEncoder as Encoder<<T as EncodingAdapter>::Delta>>::Error,
-        >,
-    {
-        let typed_params =
-            <<T as EncodingAdapter>::ParametersEncoder>::deserialize(parameters.as_ref())?;
-        let typed_delta = <<T as EncodingAdapter>::DeltaEncoder>::deserialize(delta.as_ref())?;
-        <T as TypedContract>::verify_delta(typed_params, typed_delta)
-    }
-
     pub fn inner_update_state<T>(
         parameters: Parameters<'static>,
         state: State<'static>,
diff --git a/rust/src/memory.rs b/rust/src/memory.rs
index 35e9ca7..a9aac7a 100644
--- a/rust/src/memory.rs
+++ b/rust/src/memory.rs
@@ -82,26 +82,6 @@ pub mod wasm_interface {
         ContractInterfaceResult::from(result).into_raw()
     }
 
-    pub fn inner_validate_delta<T: ContractInterface>(parameters: i64, delta: i64) -> i64 {
-        if let Err(e) = set_logger().map_err(|e| e.into_raw()) {
-            return e;
-        }
-        let parameters = unsafe {
-            let param_buf = &mut *(parameters as *mut super::buf::BufferBuilder);
-            let bytes =
-                &*std::ptr::slice_from_raw_parts(param_buf.start(), param_buf.bytes_written());
-            Parameters::from(bytes)
-        };
-        let delta = unsafe {
-            let delta_buf = &mut *(delta as *mut super::buf::BufferBuilder);
-            let bytes =
-                &*std::ptr::slice_from_raw_parts(delta_buf.start(), delta_buf.bytes_written());
-            StateDelta::from(bytes)
-        };
-        let result = <T as ContractInterface>::validate_delta(parameters, delta);
-        ContractInterfaceResult::from(result).into_raw()
-    }
-
     pub fn inner_update_state<T: ContractInterface>(
         parameters: i64,
         state: i64,
diff --git a/typescript/src/lib.rs b/typescript/src/lib.rs
index 5d2f012..1aae866 100644
--- a/typescript/src/lib.rs
+++ b/typescript/src/lib.rs
@@ -12,13 +12,6 @@ impl ContractInterface for Contract {
         Ok(ValidateResult::Valid)
     }
 
-    fn validate_delta(
-        _parameters: Parameters<'static>,
-        _delta: StateDelta<'static>,
-    ) -> Result<bool, ContractError> {
-        Ok(true)
-    }
-
     fn update_state(
         _parameters: Parameters<'static>,
         state: State<'static>,