diff --git a/Cargo.toml b/Cargo.toml
index 972fa72..fa667f1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,8 +12,8 @@ keywords = ["rustdt", "jsonrpc", "json-rpc", "rpc"]
 [dependencies]
 rustdt_util = "0.2.3"
 log = "0.3.6"
-serde = "0.8"
-serde_json = "0.8"
+serde = "1.0"
+serde_json = "1.0"
 futures = "0.1.3"
 
 [dev-dependencies]
diff --git a/src/json_util.rs b/src/json_util.rs
index 00bc150..bd7ec1f 100644
--- a/src/json_util.rs
+++ b/src/json_util.rs
@@ -5,27 +5,18 @@
 // This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::collections::BTreeMap;
 use std::fmt;
+use std::marker::PhantomData;
 
 use serde;
 
 use serde_json::Map;
 use serde_json::Value;
-use serde_json::builder::ObjectBuilder;
 
 pub type JsonObject = Map<String, Value>;
 
 /* ----------------- deserialize helpers ----------------- */
 
-pub fn new_object() -> JsonObject {
-    BTreeMap::new()
-}
-
-pub fn unwrap_object_builder(ob: ObjectBuilder) -> JsonObject {
-    unwrap_object(ob.build())
-}
-
 pub fn unwrap_object(value: Value) -> JsonObject {
     match value {
         Value::Object(o) => o ,
@@ -79,16 +70,20 @@ pub trait JsonDeserializerHelper<ERR> {
     
     fn as_u32(&mut self, value: Value) -> Result<u32, ERR> {
         match value {
-            Value::I64(num) => Ok(num as u32), // FIXME: check for truncation
-            Value::U64(num) => Ok(num as u32), // FIXME: check for truncation
+            Value::Number(num) => match num.as_u64() {
+                Some(num) => Ok(num as u32), // FIXME: check for truncation
+                None => Err(self.new_error(&format!("Value `{}` is not an Integer.", num))),
+            },
             _ => Err(self.new_error(&format!("Value `{}` is not an Integer.", value))),
         }
     }
     
     fn as_i64(&mut self, value: Value) -> Result<i64, ERR> {
         match value {
-            Value::I64(num) => Ok(num),
-            Value::U64(num) => Ok(num as i64), // FIXME: check for truncation
+            Value::Number(num) => match num.as_i64() {
+                Some(num) => Ok(num),
+                None => Err(self.new_error(&format!("Value `{}` is not an Integer.", num))),
+            },
             _ => Err(self.new_error(&format!("Value `{}` is not an Integer.", value))),
         }
     }
@@ -131,10 +126,16 @@ pub trait JsonDeserializerHelper<ERR> {
 
 }
 
-pub struct SerdeJsonDeserializerHelper<DE>(pub DE);
+pub struct SerdeJsonDeserializerHelper<DE>(PhantomData<DE>);
 
-impl<'a, DE : serde::Deserializer> 
-    JsonDeserializerHelper<DE::Error> for SerdeJsonDeserializerHelper<&'a mut DE> 
+impl<DE> SerdeJsonDeserializerHelper<DE> {
+    pub fn new(_deserializer: &DE) -> SerdeJsonDeserializerHelper<DE> {
+        SerdeJsonDeserializerHelper(PhantomData)
+    }
+}
+
+impl<'de, DE : serde::Deserializer<'de>> 
+    JsonDeserializerHelper<DE::Error> for SerdeJsonDeserializerHelper<DE> 
 {
     fn new_error(&self, error_message: &str) -> DE::Error {
         new_de_error(error_message.into())
@@ -145,14 +146,14 @@ pub fn to_de_error<DISPLAY, DE_ERROR>(display: DISPLAY)
     -> DE_ERROR   
 where 
     DISPLAY: fmt::Display,
-    DE_ERROR: serde::Error, 
+    DE_ERROR: serde::de::Error, 
 {
     DE_ERROR::custom(format!("{}", display))
 }
 
 pub fn new_de_error<DE_ERROR>(message: String) 
     -> DE_ERROR
-    where DE_ERROR: serde::Error 
+    where DE_ERROR: serde::de::Error 
 {
     DE_ERROR::custom(message)
 }
@@ -173,13 +174,13 @@ pub mod test_util {
         serde_json::to_string(value).unwrap()
     }
     
-    pub fn from_json<T: Deserialize>(json: &str) -> T {
+    pub fn from_json<'de, T: Deserialize<'de>>(json: &'de str) -> T {
         serde_json::from_str(json).unwrap()
     }
 
     pub fn test_serde<T>(obj: &T) 
         -> (T, String)
-        where T : Serialize + Deserialize + PartialEq + Debug
+        where for<'de> T : Serialize + Deserialize<'de> + PartialEq + Debug
     {
         let json = to_json(obj);
         let reserialized : T = from_json(&json);
@@ -187,8 +188,8 @@ pub mod test_util {
         (reserialized, json)
     }
     
-    pub fn test_error_de<T>(json: &str, expected_err_contains: &str) 
-        where T : Deserialize + PartialEq + Debug
+    pub fn test_error_de<'de, T>(json: &'de str, expected_err_contains: &str) 
+        where T : Deserialize<'de> + PartialEq + Debug
     {
         let res = serde_json::from_str::<T>(json).unwrap_err();
         check_err_contains(res, expected_err_contains);
@@ -196,7 +197,7 @@ pub mod test_util {
     
     pub fn test_serde_expecting<T>(obj: &T, expected_value: &Value) 
         -> Value
-        where T : Serialize + Deserialize + PartialEq + Debug
+        where for<'de> T : Serialize + Deserialize<'de> + PartialEq + Debug
     {
         let json = test_serde(obj).1;
         
@@ -205,4 +206,4 @@ pub mod test_util {
         as_value
     }
     
-}
\ No newline at end of file
+}
diff --git a/src/jsonrpc.rs b/src/jsonrpc.rs
index bcb6548..fc920c4 100644
--- a/src/jsonrpc.rs
+++ b/src/jsonrpc.rs
@@ -24,7 +24,7 @@ https://github.com/RustDT/rustdt-json_rpc/blob/master/tests/example.rs
 #![allow(non_camel_case_types)]
 
 #[macro_use] extern crate log;
-extern crate serde_json;
+#[macro_use] extern crate serde_json;
 extern crate serde;
 
 extern crate rustdt_util as util;
@@ -275,7 +275,7 @@ impl ResponseCompletable {
         self, params: RequestParams, method_handler: METHOD
     ) 
     where 
-        PARAMS : serde::Deserialize, 
+        for<'de> PARAMS : serde::Deserialize<'de>, 
         RET : serde::Serialize, 
         RET_ERROR : serde::Serialize,
         METHOD : FnOnce(PARAMS, MethodCompletable<RET, RET_ERROR>),
@@ -288,7 +288,7 @@ impl ResponseCompletable {
         self, params: RequestParams, sync_method_handler: METHOD
     ) 
     where 
-        PARAMS : serde::Deserialize, 
+        for<'de> PARAMS : serde::Deserialize<'de>, 
         RET : serde::Serialize, 
         RET_ERROR : serde::Serialize ,
         METHOD : FnOnce(PARAMS) -> MethodResult<RET, RET_ERROR>,
@@ -303,7 +303,7 @@ impl ResponseCompletable {
         self, params: RequestParams, method_handler: METHOD
     ) 
     where 
-        PARAMS : serde::Deserialize, 
+        for<'de> PARAMS : serde::Deserialize<'de>, 
         METHOD : FnOnce(PARAMS),
     {
         let mc = MethodCompletable::<(), ()>::new(self);
@@ -318,7 +318,7 @@ impl ResponseCompletable {
         self, params: RequestParams, sync_method_handler: METHOD
     ) 
     where 
-        PARAMS : serde::Deserialize, 
+        for<'de> PARAMS : serde::Deserialize<'de>, 
         METHOD : FnOnce(PARAMS),
     {
         self.handle_notification_with(params, |params| {
@@ -359,7 +359,7 @@ impl<
         method_fn: METHOD
     )
     where 
-        PARAMS : serde::Deserialize, 
+        for<'de> PARAMS : serde::Deserialize<'de>, 
         RET : serde::Serialize, 
         RET_ERROR : serde::Serialize,
         METHOD : FnOnce(PARAMS, Self),
@@ -421,11 +421,14 @@ impl Endpoint {
     
     /// Send a (non-notification) request
     pub fn send_request<
+        RET,
+        RET_ERROR,
         PARAMS : serde::Serialize, 
-        RET: serde::Deserialize, 
-        RET_ERROR : serde::Deserialize, 
     >(&mut self, method_name: &str, params: PARAMS) 
         -> GResult<RequestFuture<RET, RET_ERROR>> 
+    where
+        for<'de> RET: serde::Deserialize<'de>, 
+        for<'de> RET_ERROR : serde::Deserialize<'de>, 
     {
         let (completable, future) = futures::oneshot::<ResponseResult>();
         let future : futures::Oneshot<ResponseResult> = future;
@@ -459,7 +462,7 @@ impl Endpoint {
     >(&self, id: Option<Id>, method_name: &str, params: PARAMS) 
         -> GResult<()> 
     {
-        let params_value = serde_json::to_value(&params);
+        let params_value = serde_json::to_value(&params)?;
         let params = jsonrpc_request::to_jsonrpc_params(params_value)?;
         
         let rpc_request = Request { id: id.clone(), method : method_name.into(), params : params };
@@ -593,12 +596,12 @@ mod tests_ {
         let request = Request::new(1, "sample_fn".to_string(), JsonObject::new());
         invoke_method(&mut request_handler, &request.method, request.params, 
             |result| 
-            check_request(result.unwrap(), ResponseResult::Error(error_JSON_RPC_InvalidParams(r#"missing field "x""#)))
+            check_request(result.unwrap(), ResponseResult::Error(error_JSON_RPC_InvalidParams(r#"missing field `x`"#)))
         );
         
         // test with valid params
         let params_value = match serde_json::to_value(&new_sample_params(10, 20)) {
-            Value::Object(object) => object, 
+            Ok(Value::Object(object)) => object, 
             _ => panic!("Not serialized into Object") 
         };
         let request = Request::new(1, "sample_fn".to_string(), params_value);
diff --git a/src/jsonrpc_common.rs b/src/jsonrpc_common.rs
index 4641882..acb3d31 100644
--- a/src/jsonrpc_common.rs
+++ b/src/jsonrpc_common.rs
@@ -9,11 +9,12 @@ use std::fmt;
 
 use serde;
 use serde::de::Visitor;
-use serde::Error;
+use serde::ser::SerializeStruct;
 
 use serde_json::Value;
 use serde_json;
 use json_util::*;
+use json_util::JsonDeserializerHelper;
 
 
 
@@ -33,7 +34,7 @@ pub fn parse_jsonrpc_id(id: Value) -> JsonRpcParseResult<Option<Id>> {
 pub enum Id { Number(u64), String(String), Null, }
 
 impl serde::Serialize for Id {
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: serde::Serializer,
     {
         match *self {
@@ -44,33 +45,38 @@ impl serde::Serialize for Id {
     }
 }
 
-impl serde::Deserialize for Id {
-    fn deserialize<DE>(deserializer: &mut DE) -> Result<Self, DE::Error>
-        where DE: serde::Deserializer 
+impl<'de> serde::Deserialize<'de> for Id {
+    fn deserialize<DE>(deserializer: DE) -> Result<Self, DE::Error>
+        where DE: serde::Deserializer<'de> 
     {
-        deserializer.deserialize(IdDeserializeVisitor)
+        deserializer.deserialize_any(IdDeserializeVisitor)
     }
 }
 
 struct IdDeserializeVisitor;
 
-impl Visitor for IdDeserializeVisitor {
+impl<'de> Visitor<'de> for IdDeserializeVisitor {
     type Value = Id;
     
-    fn visit_unit<E>(&mut self) -> Result<Self::Value, E> where E: Error,
+    fn visit_unit<E>(self) -> Result<Self::Value, E>
     {
         Ok(Id::Null)
     }
     
-    fn visit_u64<E>(&mut self, value: u64) -> Result<Self::Value, E> where E: Error,
+    fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
     {
         Ok(Id::Number(value))
     }
     
-    fn visit_str<E>(&mut self, value: &str) -> Result<Self::Value, E> where E: Error,
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
     {
         Ok(Id::String(value.to_string()))
     }
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result
+    {
+        formatter.write_str("an ID")
+    }
 }
 
 impl fmt::Display for Id {
@@ -130,28 +136,28 @@ pub fn error_JSON_RPC_InvalidResponse<T: fmt::Display>(error: T) -> RequestError
 }
 
 impl serde::Serialize for RequestError {
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: serde::Serializer
     {
         let elem_count = 3;
         let mut state = try!(serializer.serialize_struct("RequestError", elem_count)); 
         {
-            try!(serializer.serialize_struct_elt(&mut state, "code", self.code));
-            try!(serializer.serialize_struct_elt(&mut state, "message", &self.message));
+            try!(state.serialize_field("code", &self.code));
+            try!(state.serialize_field("message", &self.message));
             if let Some(ref data) = self.data {
-                try!(serializer.serialize_struct_elt(&mut state, "data", data));
+                try!(state.serialize_field("data", data));
             }
         }
-        serializer.serialize_struct_end(state)
+        state.end()
     }
 }
 
-impl serde::Deserialize for RequestError {
-    fn deserialize<DE>(deserializer: &mut DE) -> Result<Self, DE::Error>
-        where DE: serde::Deserializer 
+impl<'de> serde::Deserialize<'de> for RequestError {
+    fn deserialize<DE>(deserializer: DE) -> Result<Self, DE::Error>
+        where DE: serde::Deserializer<'de> 
     {
-        let mut helper = SerdeJsonDeserializerHelper(deserializer);
-        let value : Value = try!(Value::deserialize(helper.0));
+        let mut helper = SerdeJsonDeserializerHelper::new(&deserializer);
+        let value : Value = try!(Value::deserialize(deserializer));
         let mut json_obj = try!(helper.as_Object(value));
         
         let code = try!(helper.obtain_i64(&mut json_obj, "code"));
diff --git a/src/jsonrpc_message.rs b/src/jsonrpc_message.rs
index 8c68084..ffc2e33 100644
--- a/src/jsonrpc_message.rs
+++ b/src/jsonrpc_message.rs
@@ -36,7 +36,7 @@ impl From<Request> for Message {
 }
 
 impl serde::Serialize for Message {
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: serde::Serializer
     {
         match *self {
@@ -46,12 +46,12 @@ impl serde::Serialize for Message {
     }
 }
 
-impl serde::Deserialize for Message {
-    fn deserialize<DE>(deserializer: &mut DE) -> Result<Self, DE::Error>
-        where DE: serde::Deserializer 
+impl<'de> serde::Deserialize<'de> for Message {
+    fn deserialize<DE>(deserializer: DE) -> Result<Self, DE::Error>
+        where DE: serde::Deserializer<'de> 
     {
-        let mut helper = SerdeJsonDeserializerHelper(deserializer);
-        let value = try!(Value::deserialize(helper.0));
+        let mut helper = SerdeJsonDeserializerHelper::new(&deserializer);
+        let value = try!(Value::deserialize(deserializer));
         let json_obj = try!(helper.as_Object(value));
         
         if json_obj.contains_key("method") {
@@ -93,4 +93,4 @@ pub mod message_tests {
         test_serde::<Message>(&Request::new(1, "myMethod".to_string(), sample_params).into());
     }
     
-}
\ No newline at end of file
+}
diff --git a/src/jsonrpc_request.rs b/src/jsonrpc_request.rs
index 2ece5a5..5391bd5 100644
--- a/src/jsonrpc_request.rs
+++ b/src/jsonrpc_request.rs
@@ -5,11 +5,12 @@
 // This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::fmt;
 
 use serde;
 use serde::de::Visitor;
 use serde::de;
-use serde::Error;
+use serde::ser::SerializeStruct;
 
 use serde_json;
 use serde_json::Value;
@@ -55,7 +56,7 @@ impl Request {
 }
 
 impl serde::Serialize for Request {
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: serde::Serializer
     {
         // TODO: need to investigate if elem_count = 4 is actually valid when id is missing
@@ -63,23 +64,23 @@ impl serde::Serialize for Request {
         let elem_count = 4;
         let mut state = try!(serializer.serialize_struct("Request", elem_count)); 
         {
-            try!(serializer.serialize_struct_elt(&mut state, "jsonrpc", "2.0"));
+            try!(state.serialize_field("jsonrpc", "2.0"));
             if let Some(ref id) = self.id {
-                try!(serializer.serialize_struct_elt(&mut state, "id", id));
+                try!(state.serialize_field("id", id));
             }
-            try!(serializer.serialize_struct_elt(&mut state, "method", &self.method));
-            try!(serializer.serialize_struct_elt(&mut state, "params", &self.params));
+            try!(state.serialize_field("method", &self.method));
+            try!(state.serialize_field("params", &self.params));
         }
-        serializer.serialize_struct_end(state)
+        state.end()
     }
 }
 
-impl serde::Deserialize for Request {
-    fn deserialize<DE>(deserializer: &mut DE) -> Result<Self, DE::Error>
-        where DE: serde::Deserializer 
+impl<'de> serde::Deserialize<'de> for Request {
+    fn deserialize<DE>(deserializer: DE) -> Result<Self, DE::Error>
+        where DE: serde::Deserializer<'de> 
     {
-        let mut helper = SerdeJsonDeserializerHelper(deserializer);
-        let value = try!(Value::deserialize(helper.0));
+        let mut helper = SerdeJsonDeserializerHelper::new(&deserializer);
+        let value = try!(Value::deserialize(deserializer));
         let mut json_obj = try!(helper.as_Object(value));
         
         try!(check_jsonrpc_field(&mut helper, &mut json_obj));
@@ -119,7 +120,7 @@ impl RequestParams {
 }
 
 impl serde::Serialize for RequestParams {
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: serde::Serializer
     {
         match *self {
@@ -139,39 +140,48 @@ pub fn to_jsonrpc_params(params: Value) -> GResult<RequestParams> {
     }
 }
 
-impl serde::Deserialize for RequestParams {
-    fn deserialize<DE>(deserializer: &mut DE) -> Result<Self, DE::Error>
-        where DE: serde::Deserializer 
+impl<'de> serde::Deserialize<'de> for RequestParams {
+    fn deserialize<DE>(deserializer: DE) -> Result<Self, DE::Error>
+        where DE: serde::Deserializer<'de> 
     {
-        deserializer.deserialize(RequestParams_DeserializeVisitor)
+        deserializer.deserialize_any(RequestParams_DeserializeVisitor)
     }
 }
 
 struct RequestParams_DeserializeVisitor;
 
-impl Visitor for RequestParams_DeserializeVisitor {
+impl<'de> Visitor<'de> for RequestParams_DeserializeVisitor {
     type Value = RequestParams;
     
-    fn visit_unit<E>(&mut self) -> Result<Self::Value, E> 
-        where E: Error,
+    fn visit_unit<E>(self) -> Result<Self::Value, E> 
     {
         Ok(RequestParams::None)
     }
     
-    fn visit_seq<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
-        where V: de::SeqVisitor,
+    fn visit_seq<V>(self, mut access: V) -> Result<Self::Value, V::Error>
+        where V: de::SeqAccess<'de>,
     {
-        let values = try!(de::impls::VecVisitor::new().visit_seq(visitor));
+        let mut values = Vec::new();
+        while let Some(value) = access.next_element()? {
+            values.push(value);
+        }
         Ok(RequestParams::Array(values))
     }
 
-    fn visit_map<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
-        where V: de::MapVisitor,
+    fn visit_map<V>(self, mut access: V) -> Result<Self::Value, V::Error>
+        where V: de::MapAccess<'de>,
     {
-        let values = try!(de::impls::BTreeMapVisitor::new().visit_map(visitor));
+        let mut values = serde_json::value::Map::new();
+        while let Some((key, value)) = access.next_entry()? {
+            values.insert(key, value);
+        }
         Ok(RequestParams::Object(values))
     }
     
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result
+    {
+        formatter.write_str("params")
+    }
 }
 
 
@@ -187,16 +197,15 @@ pub mod request_tests {
     use jsonrpc_common::*;
     
     use serde_json::Value;
-    use serde_json::builder::ObjectBuilder;
 
 
     #[test]
     fn test__RequestParams() {
         
-        let sample_obj = unwrap_object_builder(ObjectBuilder::new().insert("xxx", 123));
+        let sample_obj = json!({"xxx": 123}).as_object().unwrap().clone();
         let sample_string = Value::String("blah".into());
         
-        test_serde__RequestParams(RequestParams::Object(sample_obj.clone()));
+        test_serde__RequestParams(RequestParams::Object(sample_obj));
         test_serde__RequestParams(RequestParams::Array(vec![sample_string.clone(), sample_string]));
         test_serde__RequestParams(RequestParams::None);
     }
@@ -214,10 +223,10 @@ pub mod request_tests {
     #[test]
     fn test_Request() {
         
-        let sample_params = unwrap_object_builder(ObjectBuilder::new()
-            .insert("param", "2.0")
-            .insert("foo", 123)
-        );
+        let sample_params = json!({
+            "param": "2.0",
+            "foo": 123,
+        }).as_object().unwrap().clone();
         
         // Test invalid JSON
         test_error_de::<Request>(
@@ -258,7 +267,7 @@ pub mod request_tests {
         // --- Test serialization ---
         
         // basic Request
-        let request = Request::new(1, "myMethod".to_string(), sample_params.clone());
+        let request = Request::new(1, "myMethod".to_string(), sample_params);
         test_serde(&request);
         
         // Test basic Request, no params
@@ -271,4 +280,4 @@ pub mod request_tests {
         test_serde(&request);
     }
     
-}
\ No newline at end of file
+}
diff --git a/src/jsonrpc_response.rs b/src/jsonrpc_response.rs
index 6f46992..6798928 100644
--- a/src/jsonrpc_response.rs
+++ b/src/jsonrpc_response.rs
@@ -7,6 +7,7 @@
 
 
 use serde;
+use serde::ser::SerializeStruct;
 use serde_json;
 use serde_json::Value;
 
@@ -60,34 +61,34 @@ impl ResponseResult {
 
 
 impl serde::Serialize for Response {
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: serde::Serializer
     {
         let elem_count = 3;
         let mut state = try!(serializer.serialize_struct("Response", elem_count));
         {
-            try!(serializer.serialize_struct_elt(&mut state, "jsonrpc", "2.0"));
-            try!(serializer.serialize_struct_elt(&mut state, "id", &self.id));
+            try!(state.serialize_field("jsonrpc", "2.0"));
+            try!(state.serialize_field("id", &self.id));
             
             match self.result_or_error {
                 ResponseResult::Result(ref value) => {
-                    try!(serializer.serialize_struct_elt(&mut state, "result", &value));
+                    try!(state.serialize_field("result", &value));
                 }
                 ResponseResult::Error(ref json_rpc_error) => {
-                    try!(serializer.serialize_struct_elt(&mut state, "error", &json_rpc_error)); 
+                    try!(state.serialize_field("error", &json_rpc_error)); 
                 }
             }
         }
-        serializer.serialize_struct_end(state)
+        state.end()
     }
 }
 
-impl serde::Deserialize for Response {
-    fn deserialize<DE>(deserializer: &mut DE) -> Result<Self, DE::Error>
-        where DE: serde::Deserializer 
+impl<'de> serde::Deserialize<'de> for Response {
+    fn deserialize<DE>(deserializer: DE) -> Result<Self, DE::Error>
+        where DE: serde::Deserializer<'de> 
     {
-        let mut helper = SerdeJsonDeserializerHelper(deserializer);
-        let value = try!(Value::deserialize(helper.0));
+        let mut helper = SerdeJsonDeserializerHelper::new(&deserializer);
+        let value = try!(Value::deserialize(deserializer));
         let mut json_obj = try!(helper.as_Object(value));
         
         try!(check_jsonrpc_field(&mut helper, &mut json_obj));
@@ -121,10 +122,9 @@ pub mod response_tests {
     use json_util::test_util::*;
     
     use serde_json::Value;
-    use serde_json::builder::ObjectBuilder;
 
     pub fn sample_json_obj(foo: u32) -> Value {
-        ObjectBuilder::new().insert("foo", foo).build()
+        json!({"foo": foo})
     }
     
     #[test]
@@ -150,42 +150,38 @@ pub mod response_tests {
 
         
         let response = Response::new_result(Id::Null, sample_json_obj(100));
-        test_serde_expecting(&response, &ObjectBuilder::new()
-            .insert("jsonrpc", "2.0")
-            .insert("id", Id::Null)
-            .insert("result", sample_json_obj(100))
-            .build()
-        ); 
+        test_serde_expecting(&response, &json!({
+            "jsonrpc": "2.0",
+            "id": Id::Null,
+            "result": sample_json_obj(100),
+        })); 
         
         let response = Response::new_result(Id::Number(123), sample_json_obj(200));
-        test_serde_expecting(&response, &ObjectBuilder::new()
-            .insert("jsonrpc", "2.0")
-            .insert("id", 123)
-            .insert("result", sample_json_obj(200))
-            .build()
-        );
+        test_serde_expecting(&response, &json!({
+            "jsonrpc": "2.0",
+            "id": 123,
+            "result": sample_json_obj(200),
+        }));
         
         let response = Response::new_result(Id::Null, sample_json_obj(200));
-        test_serde_expecting(&response, &ObjectBuilder::new()
-            .insert("jsonrpc", "2.0")
-            .insert("id", Value::Null)
-            .insert("result", sample_json_obj(200))
-            .build()
-        );
+        test_serde_expecting(&response, &json!({
+            "jsonrpc": "2.0",
+            "id": Value::Null,
+            "result": sample_json_obj(200),
+        }));
         
         let response = Response::new_error(Id::String("321".to_string()), RequestError{
             code: 5, message: "msg".to_string(), data: Some(sample_json_obj(300))
         });
-        test_serde_expecting(&response, &ObjectBuilder::new()
-            .insert("jsonrpc", "2.0")
-            .insert("id", "321")
-            .insert("error", unwrap_object_builder(ObjectBuilder::new()
-                .insert("code", 5)
-                .insert("message", "msg")
-                .insert("data", sample_json_obj(300))
-            ))
-            .build()
-        );
+        test_serde_expecting(&response, &json!({
+            "jsonrpc": "2.0",
+            "id": "321",
+            "error": {
+                "code": 5,
+                "message": "msg",
+                "data": sample_json_obj(300),
+            },
+        }));
         
     }
 }
diff --git a/src/map_request_handler.rs b/src/map_request_handler.rs
index b37cf46..09c1064 100644
--- a/src/map_request_handler.rs
+++ b/src/map_request_handler.rs
@@ -32,13 +32,14 @@ impl MapRequestHandler {
          MapRequestHandler { method_handlers : HashMap::new() }
     }
     
-    pub fn add_notification<
-        PARAMS : serde::Deserialize + 'static,
-    >(
+    pub fn add_notification<PARAMS>(
         &mut self,
         method_name: &'static str, 
         method_fn: Box<Fn(PARAMS)>
-    ) {
+    )
+    where
+        for<'de> PARAMS : serde::Deserialize<'de> + 'static,
+    {
         let req_handler : Box<RpcMethodHandler> = new(move |params, completable| {
             completable.sync_handle_notification(params, &*method_fn);
         });
@@ -46,14 +47,17 @@ impl MapRequestHandler {
     }
     
     pub fn add_request<
-        PARAMS : serde::Deserialize + 'static, 
+        PARAMS,
         RET : serde::Serialize + 'static, 
         RET_ERROR : serde::Serialize + 'static
     >(
         &mut self,
         method_name: &'static str, 
         method_fn: Box<Fn(PARAMS) -> MethodResult<RET, RET_ERROR>>
-    ) {
+    )
+    where
+        for<'de> PARAMS : serde::Deserialize<'de> + 'static, 
+    {
         let req_handler : Box<RpcMethodHandler> = new(move |params, completable| {
             completable.sync_handle_request(params, &*method_fn);
         });
diff --git a/src/method_types.rs b/src/method_types.rs
index ab3c1dc..91ddba5 100644
--- a/src/method_types.rs
+++ b/src/method_types.rs
@@ -41,14 +41,14 @@ where
     {
         match method_result {
             Ok(ret) => {
-                ResponseResult::Result(serde_json::to_value(&ret)) 
+                ResponseResult::Result(serde_json::to_value(&ret).unwrap()) 
             } 
             Err(error) => {
                 let code : u32 = error.code;
                 let request_error = RequestError { 
                     code : code as i64, // Safe convertion. TODO: use TryFrom when it's stable
                     message : error.message,
-                    data : Some(serde_json::to_value(&error.data)),
+                    data : Some(serde_json::to_value(&error.data).unwrap()),
                 };
                 ResponseResult::Error(request_error)
             }
@@ -78,10 +78,10 @@ impl<RET, RET_ERROR> RequestResult<RET, RET_ERROR> {
     }
 }
 
-impl<
-    RET : serde::Deserialize, 
-    RET_ERROR : serde::Deserialize, 
-> From<ResponseResult> for RequestResult<RET, RET_ERROR> 
+impl<RET, RET_ERROR> From<ResponseResult> for RequestResult<RET, RET_ERROR> 
+where
+    for<'de> RET : serde::Deserialize<'de>, 
+    for<'de> RET_ERROR : serde::Deserialize<'de>, 
 {
     fn from(response_result : ResponseResult) -> Self 
     {
@@ -118,18 +118,18 @@ impl<
         
         // Test Ok
         let params = new_sample_params(10, 20);
-        let response_result = ResponseResult::Result(serde_json::to_value(&params));
+        let response_result = ResponseResult::Result(serde_json::to_value(&params).unwrap());
         assert_eq!(
             RequestResult::<Point, ()>::from(response_result), 
             RequestResult::MethodResult(Ok(params.clone()))
         );
         
         // Test invalid MethodResult response 
-        let response_result = ResponseResult::Result(serde_json::to_value(&new_sample_params(10, 20)));
+        let response_result = ResponseResult::Result(serde_json::to_value(&new_sample_params(10, 20)).unwrap());
         assert_eq!(
             RequestResult::<String, ()>::from(response_result), 
             RequestResult::RequestError(error_JSON_RPC_InvalidResponse(
-                r#"invalid type: map at line 0 column 0"#))
+                r#"invalid type: map, expected a string"#))
         );
     }
-    
\ No newline at end of file
+    
diff --git a/src/tests_sample_types.rs b/src/tests_sample_types.rs
index a61b821..86837ee 100644
--- a/src/tests_sample_types.rs
+++ b/src/tests_sample_types.rs
@@ -3,7 +3,10 @@
 
 #![cfg(test)]
 
+use std::fmt;
+
 use serde;
+use serde::ser::SerializeStruct;
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct Point {
@@ -28,16 +31,16 @@ pub enum PointField {
 }
 
 
-impl serde::Deserialize for PointField {
-    fn deserialize<D>(deserializer: &mut D) -> Result<PointField, D::Error>
-        where D: serde::de::Deserializer
+impl<'de> serde::Deserialize<'de> for PointField {
+    fn deserialize<D>(deserializer: D) -> Result<PointField, D::Error>
+        where D: serde::de::Deserializer<'de>
     {
         struct PointFieldVisitor;
 
-        impl serde::de::Visitor for PointFieldVisitor {
+        impl<'de> serde::de::Visitor<'de> for PointFieldVisitor {
             type Value = PointField;
 
-            fn visit_str<E>(&mut self, value: &str) -> Result<PointField, E>
+            fn visit_str<E>(self, value: &str) -> Result<PointField, E>
                 where E: serde::de::Error
             {
                 match value {
@@ -46,15 +49,20 @@ impl serde::Deserialize for PointField {
                     _ => Err(serde::de::Error::custom("expected x or y")),
                 }
             }
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result
+            {
+                formatter.write_str("x or y")
+            }
         }
 
-        deserializer.deserialize(PointFieldVisitor)
+        deserializer.deserialize_any(PointFieldVisitor)
     }
 }
 
-impl serde::Deserialize for Point {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Point, D::Error>
-        where D: serde::de::Deserializer
+impl<'de> serde::Deserialize<'de> for Point {
+    fn deserialize<D>(deserializer: D) -> Result<Point, D::Error>
+        where D: serde::de::Deserializer<'de>
     {
         static FIELDS: &'static [&'static str] = &["x", "y"];
         deserializer.deserialize_struct("Point", FIELDS, PointVisitor)
@@ -63,50 +71,53 @@ impl serde::Deserialize for Point {
 
 struct PointVisitor;
 
-impl serde::de::Visitor for PointVisitor {
+impl<'de> serde::de::Visitor<'de> for PointVisitor {
     type Value = Point;
 
-    fn visit_map<V>(&mut self, mut visitor: V) -> Result<Point, V::Error>
-        where V: serde::de::MapVisitor
+    fn visit_map<V>(self, mut visitor: V) -> Result<Point, V::Error>
+        where V: serde::de::MapAccess<'de>
     {
         let mut x = None;
         let mut y = None;
 
         loop {
-            match try!(visitor.visit_key()) {
-                Some(PointField::X) => { x = Some(try!(visitor.visit_value())); }
-                Some(PointField::Y) => { y = Some(try!(visitor.visit_value())); }
+            match try!(visitor.next_key()) {
+                Some(PointField::X) => { x = Some(try!(visitor.next_value())); }
+                Some(PointField::Y) => { y = Some(try!(visitor.next_value())); }
                 None => { break; }
             }
         }
 
         let x = match x {
             Some(x) => x,
-            None => try!(visitor.missing_field("x")),
+            None => return Err(<V::Error as serde::de::Error>::missing_field("x")),
         };
 
         let y = match y {
             Some(y) => y,
-            None => try!(visitor.missing_field("y")),
+            None => return Err(<V::Error as serde::de::Error>::missing_field("y")),
         };
 
-        try!(visitor.end());
-
         Ok(Point{ x: x, y: y })
     }
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result
+    {
+        formatter.write_str("a point")
+    }
 }
 
 
 impl serde::Serialize for Point {
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: serde::Serializer,
     {
         let elem_count = 2;
         let mut state = try!(serializer.serialize_struct("Point", elem_count)); 
         {
-            try!(serializer.serialize_struct_elt(&mut state, "x", &self.x));
-            try!(serializer.serialize_struct_elt(&mut state, "y", &self.y));
+            try!(state.serialize_field("x", &self.x));
+            try!(state.serialize_field("y", &self.y));
         }
-        serializer.serialize_struct_end(state)
+        state.end()
     }
 }
diff --git a/tests/tests_sample_types.rs b/tests/tests_sample_types.rs
index e23520a..8399d57 100644
--- a/tests/tests_sample_types.rs
+++ b/tests/tests_sample_types.rs
@@ -3,7 +3,10 @@
 
 #![cfg(test)]
 
+use std::fmt;
+
 extern crate serde;
+use serde::ser::SerializeStruct;
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct Point {
@@ -21,16 +24,16 @@ pub enum PointField {
 }
 
 
-impl serde::Deserialize for PointField {
-    fn deserialize<D>(deserializer: &mut D) -> Result<PointField, D::Error>
-        where D: serde::de::Deserializer
+impl<'de> serde::Deserialize<'de> for PointField {
+    fn deserialize<D>(deserializer: D) -> Result<PointField, D::Error>
+        where D: serde::de::Deserializer<'de>
     {
         struct PointFieldVisitor;
 
-        impl serde::de::Visitor for PointFieldVisitor {
+        impl<'de> serde::de::Visitor<'de> for PointFieldVisitor {
             type Value = PointField;
 
-            fn visit_str<E>(&mut self, value: &str) -> Result<PointField, E>
+            fn visit_str<E>(self, value: &str) -> Result<PointField, E>
                 where E: serde::de::Error
             {
                 match value {
@@ -39,15 +42,20 @@ impl serde::Deserialize for PointField {
                     _ => Err(serde::de::Error::custom("expected x or y")),
                 }
             }
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result
+            {
+                formatter.write_str("x or y")
+            }
         }
 
-        deserializer.deserialize(PointFieldVisitor)
+        deserializer.deserialize_any(PointFieldVisitor)
     }
 }
 
-impl serde::Deserialize for Point {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Point, D::Error>
-        where D: serde::de::Deserializer
+impl<'de> serde::Deserialize<'de> for Point {
+    fn deserialize<D>(deserializer: D) -> Result<Point, D::Error>
+        where D: serde::de::Deserializer<'de>
     {
         static FIELDS: &'static [&'static str] = &["x", "y"];
         deserializer.deserialize_struct("Point", FIELDS, PointVisitor)
@@ -56,50 +64,53 @@ impl serde::Deserialize for Point {
 
 struct PointVisitor;
 
-impl serde::de::Visitor for PointVisitor {
+impl<'de> serde::de::Visitor<'de> for PointVisitor {
     type Value = Point;
 
-    fn visit_map<V>(&mut self, mut visitor: V) -> Result<Point, V::Error>
-        where V: serde::de::MapVisitor
+    fn visit_map<V>(self, mut visitor: V) -> Result<Point, V::Error>
+        where V: serde::de::MapAccess<'de>
     {
         let mut x = None;
         let mut y = None;
 
         loop {
-            match try!(visitor.visit_key()) {
-                Some(PointField::X) => { x = Some(try!(visitor.visit_value())); }
-                Some(PointField::Y) => { y = Some(try!(visitor.visit_value())); }
+            match try!(visitor.next_key()) {
+                Some(PointField::X) => { x = Some(try!(visitor.next_value())); }
+                Some(PointField::Y) => { y = Some(try!(visitor.next_value())); }
                 None => { break; }
             }
         }
 
         let x = match x {
             Some(x) => x,
-            None => try!(visitor.missing_field("x")),
+            None => return Err(<V::Error as serde::de::Error>::missing_field("x")),
         };
 
         let y = match y {
             Some(y) => y,
-            None => try!(visitor.missing_field("y")),
+            None => return Err(<V::Error as serde::de::Error>::missing_field("y")),
         };
 
-        try!(visitor.end());
-
         Ok(Point{ x: x, y: y })
     }
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result
+    {
+        formatter.write_str("a point")
+    }
 }
 
 
 impl serde::Serialize for Point {
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where S: serde::Serializer,
     {
         let elem_count = 2;
         let mut state = try!(serializer.serialize_struct("Point", elem_count)); 
         {
-            try!(serializer.serialize_struct_elt(&mut state, "x", &self.x));
-            try!(serializer.serialize_struct_elt(&mut state, "y", &self.y));
+            try!(state.serialize_field("x", &self.x));
+            try!(state.serialize_field("y", &self.y));
         }
-        serializer.serialize_struct_end(state)
+        state.end()
     }
 }