diff --git a/Cargo.lock b/Cargo.lock
index 18853c1e..97abb846 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -130,6 +130,28 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6736e2428df2ca2848d846c43e88745121a6654696e349ce0054a420815a7409"
 
+[[package]]
+name = "binread"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f9def047620f016f4d5eb5a4c9b925f03175870772d354c696ec9062e942886"
+dependencies = [
+ "binread_derive",
+ "lazy_static",
+]
+
+[[package]]
+name = "binread_derive"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c575d9a28eb4c2d61747b23d50271c6699b941448c35a738af35267f90b3d4d2"
+dependencies = [
+ "either",
+ "proc-macro2 1.0.26",
+ "quote 1.0.9",
+ "syn 1.0.68",
+]
+
 [[package]]
 name = "bit-set"
 version = "0.5.2"
@@ -232,7 +254,9 @@ checksum = "b700ce4376041dcd0a327fd0097c41095743c4c8af8887265942faf1100bd040"
 name = "candid"
 version = "0.6.21"
 dependencies = [
+ "anyhow",
  "arbitrary",
+ "binread",
  "byteorder",
  "candid_derive",
  "codespan-reporting",
diff --git a/rust/candid/Cargo.toml b/rust/candid/Cargo.toml
index 56dcc78b..883a2aa1 100644
--- a/rust/candid/Cargo.toml
+++ b/rust/candid/Cargo.toml
@@ -35,6 +35,8 @@ pretty = "0.10.0"
 serde = { version = "1.0.118", features = ["derive"] }
 serde_bytes = "0.11"
 thiserror = "1.0.20"
+anyhow = "1.0"
+binread = { version = "2.0", features = ["debug_template"] }
 
 arbitrary = { version = "0.4.7", optional = true }
 serde_dhall = { version = "0.10.0", optional = true }
diff --git a/rust/candid/src/binary_parser.rs b/rust/candid/src/binary_parser.rs
new file mode 100644
index 00000000..79d876f0
--- /dev/null
+++ b/rust/candid/src/binary_parser.rs
@@ -0,0 +1,262 @@
+use crate::parser::types::FuncMode;
+use crate::parser::typing::TypeEnv;
+use crate::types::internal::{Field, Function, Label, Type};
+use anyhow::{anyhow, Context, Result};
+use binread::io::{Read, Seek, SeekFrom};
+use binread::{BinRead, BinResult, Error as BError, ReadOptions};
+use std::convert::TryInto;
+
+fn read_leb<R: Read + Seek>(reader: &mut R, ro: &ReadOptions, _: ()) -> BinResult<u64> {
+    let pos = reader.seek(SeekFrom::Current(0))?;
+    leb128::read::unsigned(reader).map_err(|_| BError::Custom {
+        pos,
+        err: Box::new(ro.variable_name.unwrap_or("Invalid leb128")),
+    })
+}
+fn read_sleb<R: Read + Seek>(reader: &mut R, ro: &ReadOptions, _: ()) -> BinResult<i64> {
+    let pos = reader.seek(SeekFrom::Current(0))?;
+    leb128::read::signed(reader).map_err(|_| BError::Custom {
+        pos,
+        err: Box::new(ro.variable_name.unwrap_or("Invalid sleb128")),
+    })
+}
+
+#[derive(BinRead, Debug)]
+#[br(magic = b"DIDL")]
+pub struct Header {
+    table: Table,
+    #[br(parse_with = read_leb)]
+    len: u64,
+    #[br(count = len)]
+    args: Vec<IndexType>,
+}
+#[derive(BinRead, Debug)]
+struct Table {
+    #[br(parse_with = read_leb, assert(len <= i64::MAX as u64, "type table size out of range"))]
+    len: u64,
+    #[br(count = len)]
+    table: Vec<ConsType>,
+}
+#[derive(BinRead, Debug)]
+enum ConsType {
+    #[br(magic = 0x6eu8)]
+    Opt(Box<IndexType>),
+    #[br(magic = 0x6du8)]
+    Vec(Box<IndexType>),
+    #[br(magic = 0x6cu8)]
+    Record(Fields),
+    #[br(magic = 0x6bu8)]
+    Variant(Fields),
+    #[br(magic = 0x6au8)]
+    Func(FuncType),
+    #[br(magic = 0x69u8)]
+    Service(ServType),
+}
+#[derive(BinRead, Debug)]
+struct IndexType {
+    #[br(parse_with = read_sleb, assert(index >= -17 || index == -24, "unknown opcode {}", index))]
+    index: i64,
+}
+#[derive(BinRead, Debug)]
+struct Fields {
+    #[br(parse_with = read_leb, try_map = |x:u64| x.try_into().map_err(|_| "field length out of 32-bit range"))]
+    len: u32,
+    #[br(count = len)]
+    inner: Vec<FieldType>,
+}
+#[derive(BinRead, Debug)]
+struct FieldType {
+    #[br(parse_with = read_leb, try_map = |x:u64| x.try_into().map_err(|_| "field id out of 32-bit range"))]
+    id: u32,
+    index: IndexType,
+}
+#[derive(BinRead, Debug)]
+struct FuncType {
+    #[br(parse_with = read_leb)]
+    arg_len: u64,
+    #[br(count = arg_len)]
+    args: Vec<IndexType>,
+    #[br(parse_with = read_leb)]
+    ret_len: u64,
+    #[br(count = ret_len)]
+    rets: Vec<IndexType>,
+    #[br(assert(ann_len <= 1u8, "function annotation length should be at most 1"))]
+    ann_len: u8,
+    #[br(count = ann_len)]
+    ann: Vec<Mode>,
+}
+#[derive(BinRead, Debug)]
+struct ServType {
+    #[br(parse_with = read_leb)]
+    len: u64,
+    #[br(count = len)]
+    meths: Vec<Meths>,
+}
+#[derive(BinRead, Debug)]
+struct Meths {
+    #[br(parse_with = read_leb)]
+    len: u64,
+    #[br(count = len, try_map = |x:Vec<u8>| String::from_utf8(x).map_err(|_| "invalid utf8"))]
+    name: String,
+    ty: IndexType,
+}
+#[derive(BinRead, Debug)]
+struct Mode {
+    #[br(try_map = |x:u8| match x { 1u8 => Ok(FuncMode::Query), | 2u8 => Ok(FuncMode::Oneway), | _ => Err("Unknown annotation") })]
+    inner: FuncMode,
+}
+
+#[derive(BinRead)]
+pub struct BoolValue(
+    #[br(try_map = |x:u8| match x { 0u8 => Ok(false), | 1u8 => Ok(true), | _ => Err("Expect 00 or 01") } )]
+    pub bool,
+);
+#[derive(BinRead)]
+pub struct Len(
+    #[br(parse_with = read_leb, try_map = |x:u64| x.try_into().map_err(|_| "length out of usize range"))]
+    pub usize,
+);
+#[derive(BinRead)]
+pub struct PrincipalBytes {
+    #[br(assert(flag == 1u8, "Opaque reference not supported"))]
+    pub flag: u8,
+    #[br(parse_with = read_leb)]
+    pub len: u64,
+    #[br(count = len, parse_with = binread::helpers::read_bytes)]
+    pub inner: Vec<u8>,
+}
+
+fn index_to_var(ind: i64) -> String {
+    format!("table{}", ind)
+}
+impl IndexType {
+    fn to_type(&self, len: u64) -> Result<Type> {
+        Ok(match self.index {
+            v if v >= 0 => {
+                if v >= len as i64 {
+                    return Err(anyhow!("type index {} out of range", v));
+                }
+                Type::Var(index_to_var(v))
+            }
+            -1 => Type::Null,
+            -2 => Type::Bool,
+            -3 => Type::Nat,
+            -4 => Type::Int,
+            -5 => Type::Nat8,
+            -6 => Type::Nat16,
+            -7 => Type::Nat32,
+            -8 => Type::Nat64,
+            -9 => Type::Int8,
+            -10 => Type::Int16,
+            -11 => Type::Int32,
+            -12 => Type::Int64,
+            -13 => Type::Float32,
+            -14 => Type::Float64,
+            -15 => Type::Text,
+            -16 => Type::Reserved,
+            -17 => Type::Empty,
+            -24 => Type::Principal,
+            _ => unreachable!(),
+        })
+    }
+}
+impl ConsType {
+    fn to_type(&self, len: u64) -> Result<Type> {
+        Ok(match &self {
+            ConsType::Opt(ref ind) => Type::Opt(Box::new(ind.to_type(len)?)),
+            ConsType::Vec(ref ind) => Type::Vec(Box::new(ind.to_type(len)?)),
+            ConsType::Record(fs) | ConsType::Variant(fs) => {
+                let mut res = Vec::new();
+                let mut prev = None;
+                for f in fs.inner.iter() {
+                    if let Some(prev) = prev {
+                        if prev >= f.id {
+                            return Err(anyhow!("field id {} collision or not sorted", f.id));
+                        }
+                    }
+                    prev = Some(f.id);
+                    let field = Field {
+                        id: Label::Id(f.id),
+                        ty: f.index.to_type(len)?,
+                    };
+                    res.push(field);
+                }
+                if matches!(&self, ConsType::Record(_)) {
+                    Type::Record(res)
+                } else {
+                    Type::Variant(res)
+                }
+            }
+            ConsType::Func(f) => {
+                let mut args = Vec::new();
+                let mut rets = Vec::new();
+                for arg in f.args.iter() {
+                    args.push(arg.to_type(len)?);
+                }
+                for ret in f.rets.iter() {
+                    rets.push(ret.to_type(len)?);
+                }
+                Type::Func(Function {
+                    modes: f.ann.iter().map(|x| x.inner.clone()).collect(),
+                    args,
+                    rets,
+                })
+            }
+            ConsType::Service(serv) => {
+                let mut res = Vec::new();
+                let mut prev = None;
+                for m in serv.meths.iter() {
+                    if let Some(prev) = prev {
+                        if prev >= &m.name {
+                            return Err(anyhow!("method name {} duplicate or not sorted", m.name));
+                        }
+                    }
+                    prev = Some(&m.name);
+                    res.push((m.name.clone(), m.ty.to_type(len)?));
+                }
+                Type::Service(res)
+            }
+        })
+    }
+}
+impl Table {
+    fn to_env(&self, len: u64) -> Result<TypeEnv> {
+        use std::collections::BTreeMap;
+        let mut env = BTreeMap::new();
+        for (i, t) in self.table.iter().enumerate() {
+            let ty = t
+                .to_type(len)
+                .with_context(|| format!("Invalid table entry {}: {:?}", i, t))?;
+            env.insert(index_to_var(i as i64), ty);
+        }
+        // validate method has func type
+        for (_, t) in env.iter() {
+            if let Type::Service(ms) = t {
+                for (name, ty) in ms.iter() {
+                    if let Type::Var(id) = ty {
+                        if matches!(env.get(id), Some(Type::Func(_))) {
+                            continue;
+                        }
+                    }
+                    return Err(anyhow!("Method {} has a non-function type {}", name, ty));
+                }
+            }
+        }
+        Ok(TypeEnv(env))
+    }
+}
+impl Header {
+    pub fn to_types(&self) -> Result<(TypeEnv, Vec<Type>)> {
+        let len = self.table.len;
+        let mut env = self.table.to_env(len)?;
+        env.replace_empty()?;
+        let mut args = Vec::new();
+        for (i, t) in self.args.iter().enumerate() {
+            args.push(
+                t.to_type(len)
+                    .with_context(|| format!("Invalid argument entry {}: {:?}", i, t))?,
+            );
+        }
+        Ok((env, args))
+    }
+}
diff --git a/rust/candid/src/bindings/candid.rs b/rust/candid/src/bindings/candid.rs
index 9f360e40..323e5bab 100644
--- a/rust/candid/src/bindings/candid.rs
+++ b/rust/candid/src/bindings/candid.rs
@@ -115,7 +115,7 @@ pub fn pp_ty(ty: &Type) -> RcDoc {
             }
         }
         Knot(ref id) => RcDoc::text(format!("{}", id)),
-        Unknown => unreachable!(),
+        Unknown => str("unknown"),
     }
 }
 
diff --git a/rust/candid/src/de.rs b/rust/candid/src/de.rs
index 5276f44d..59b021e9 100644
--- a/rust/candid/src/de.rs
+++ b/rust/candid/src/de.rs
@@ -1,16 +1,19 @@
 //! Deserialize Candid binary format to Rust data structures
 
 use super::error::{Error, Result};
-use super::types::internal::Opcode;
-use super::{idl_hash, Int, Nat};
+use super::{
+    parser::typing::TypeEnv,
+    types::{Field, Label, Type},
+    CandidType, Int, Nat,
+};
+use crate::binary_parser::{BoolValue, Header, Len, PrincipalBytes};
+use crate::types::subtype::{subtype, Gamma};
+use anyhow::{anyhow, Context};
+use binread::BinRead;
 use byteorder::{LittleEndian, ReadBytesExt};
-use leb128::read::{signed as sleb128_decode, unsigned as leb128_decode};
-use serde::de::{self, Deserialize, Visitor};
-use std::collections::{BTreeMap, VecDeque};
-use std::convert::TryFrom;
-use std::io::Read;
-
-const MAGIC_NUMBER: &[u8; 4] = b"DIDL";
+use serde::de::{self, Visitor};
+use std::collections::VecDeque;
+use std::io::Cursor;
 
 /// Use this struct to deserialize a sequence of Rust values (heterogeneous) from IDL binary message.
 pub struct IDLDeserialize<'de> {
@@ -19,432 +22,282 @@ pub struct IDLDeserialize<'de> {
 impl<'de> IDLDeserialize<'de> {
     /// Create a new deserializer with IDL binary message.
     pub fn new(bytes: &'de [u8]) -> Result<Self> {
-        let de = Deserializer::from_bytes(bytes)?;
+        let de = Deserializer::from_bytes(bytes)
+            .with_context(|| format!("Cannot parse header {}", &hex::encode(bytes)))?;
         Ok(IDLDeserialize { de })
     }
     /// Deserialize one value from deserializer.
     pub fn get_value<T>(&mut self) -> Result<T>
     where
-        T: de::Deserialize<'de>,
+        T: de::Deserialize<'de> + CandidType,
+    {
+        self.de.is_untyped = false;
+        self.deserialize_with_type(T::ty())
+    }
+    pub fn get_value_with_type(
+        &mut self,
+        env: &TypeEnv,
+        expected_type: &Type,
+    ) -> Result<crate::parser::value::IDLValue> {
+        self.de.table.merge(env)?;
+        self.de.is_untyped = true;
+        self.deserialize_with_type(expected_type.clone())
+    }
+    fn deserialize_with_type<T>(&mut self, expected_type: Type) -> Result<T>
+    where
+        T: de::Deserialize<'de> + CandidType,
     {
-        let ty = self
-            .de
-            .table
-            .types
-            .pop_front()
-            .ok_or_else(|| Error::msg("No more values to deserialize"))?;
-        self.de.table.current_type.push_back(ty);
+        let expected_type = self.de.table.trace_type(&expected_type)?;
+        if self.de.types.is_empty() {
+            if matches!(expected_type, Type::Opt(_) | Type::Reserved | Type::Null) {
+                self.de.expect_type = expected_type;
+                self.de.wire_type = Type::Null;
+                return T::deserialize(&mut self.de);
+            } else {
+                return Err(Error::msg(format!(
+                    "No more values on the wire, the expected type {} is not opt, reserved or null",
+                    expected_type
+                )));
+            }
+        }
 
-        let v = T::deserialize(&mut self.de).map_err(|e| self.de.dump_error_state(e))?;
-        if self.de.table.current_type.is_empty() && self.de.field_name.is_none() {
-            Ok(v)
+        let (ind, ty) = self.de.types.pop_front().unwrap();
+        self.de.expect_type = if matches!(expected_type, Type::Unknown) {
+            self.de.is_untyped = true;
+            ty.clone()
         } else {
-            Err(Error::msg("Trailing type after deserializing a value"))
-                .map_err(|e| self.de.dump_error_state(e))
-        }
+            expected_type.clone()
+        };
+        self.de.wire_type = ty.clone();
+        self.de
+            .check_subtype()
+            .with_context(|| self.de.dump_state())
+            .with_context(|| {
+                format!(
+                    "Fail to decode argument {} from {} to {}",
+                    ind, ty, expected_type
+                )
+            })?;
+
+        let v = T::deserialize(&mut self.de)
+            .with_context(|| self.de.dump_state())
+            .with_context(|| {
+                format!(
+                    "Fail to decode argument {} from {} to {}",
+                    ind, ty, expected_type
+                )
+            })?;
+        Ok(v)
     }
     /// Check if we finish deserializing all values.
     pub fn is_done(&self) -> bool {
-        self.de.table.types.is_empty()
+        self.de.types.is_empty()
     }
     /// Return error if there are unprocessed bytes in the input.
     pub fn done(mut self) -> Result<()> {
         while !self.is_done() {
             self.get_value::<crate::Reserved>()?;
         }
-        if !self.de.input.0.is_empty() {
-            return Err(Error::msg("Trailing value after finishing deserialization"))
-                .map_err(|e| self.de.dump_error_state(e));
+        let ind = self.de.input.position() as usize;
+        let rest = &self.de.input.get_ref()[ind..];
+        if !rest.is_empty() {
+            return Err(anyhow!(self.de.dump_state()))
+                .context("Trailing value after finishing deserialization")?;
         }
         Ok(())
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-enum RawValue {
-    I(i64),
-    U(u32),
-}
-impl RawValue {
-    fn get_i64(&self) -> Result<i64> {
-        match *self {
-            RawValue::I(i) => Ok(i),
-            _ => Err(Error::msg(format!("get_i64 fail: {:?}", *self))),
-        }
-    }
-    fn get_u32(&self) -> Result<u32> {
-        match *self {
-            RawValue::U(u) => Ok(u),
-            _ => Err(Error::msg(format!("get_u32 fail: {:?}", *self))),
-        }
-    }
-}
-
-struct Bytes<'a>(&'a [u8]);
-impl<'a> Bytes<'a> {
-    fn from(input: &'a [u8]) -> Self {
-        Bytes(input)
-    }
-    fn leb128_read(&mut self) -> Result<u64> {
-        leb128_decode(&mut self.0).map_err(Error::msg)
-    }
-    fn sleb128_read(&mut self) -> Result<i64> {
-        sleb128_decode(&mut self.0).map_err(Error::msg)
-    }
-    fn parse_byte(&mut self) -> Result<u8> {
-        let mut buf = [0u8; 1];
-        self.0.read_exact(&mut buf)?;
-        Ok(buf[0])
-    }
-    fn parse_bytes(&mut self, len: usize) -> Result<Vec<u8>> {
-        if self.0.len() < len {
-            return Err(Error::msg("unexpected end of message"));
-        }
-        let mut buf = vec![0; len];
-        self.0.read_exact(&mut buf)?;
-        Ok(buf)
-    }
-    fn parse_string(&mut self, len: usize) -> Result<String> {
-        let buf = self.parse_bytes(len)?;
-        String::from_utf8(buf).map_err(Error::msg)
-    }
-    fn parse_magic(&mut self) -> Result<()> {
-        let mut buf = [0u8; 4];
-        match self.0.read(&mut buf) {
-            Ok(4) if buf == *MAGIC_NUMBER => Ok(()),
-            _ => Err(Error::msg(format!("wrong magic number {:?}", buf))),
-        }
-    }
-}
-
-struct TypeTable {
-    // Raw value of the type description table
-    table: Vec<Vec<RawValue>>,
-    // Value types for deserialization
-    types: VecDeque<RawValue>,
-    // The front of current_type queue always points to the type of the value we are deserailizing.
-    // The type info is cloned from table. Someone more familiar with Rust should see if we can
-    // rewrite this to avoid copying.
-    current_type: VecDeque<RawValue>,
-}
-impl TypeTable {
-    // Parse the type table and return the remaining bytes
-    fn from_bytes(input: &[u8]) -> Result<(Self, &[u8])> {
-        let mut bytes = Bytes::from(input);
-        let mut table: Vec<Vec<RawValue>> = Vec::new();
-        let mut types = VecDeque::new();
-
-        bytes.parse_magic()?;
-        let len = bytes.leb128_read()? as usize;
-        let mut expect_func = std::collections::HashSet::new();
-        for i in 0..len {
-            let mut buf = Vec::new();
-            let ty = bytes.sleb128_read()?;
-            buf.push(RawValue::I(ty));
-            if expect_func.contains(&i) && ty != -22 {
-                return Err(Error::msg(format!(
-                    "Expect function opcode, but got {}",
-                    ty
-                )));
-            }
-            match Opcode::try_from(ty) {
-                Ok(Opcode::Opt) | Ok(Opcode::Vec) => {
-                    let ty = bytes.sleb128_read()?;
-                    validate_type_range(ty, len)?;
-                    buf.push(RawValue::I(ty));
-                }
-                Ok(Opcode::Record) | Ok(Opcode::Variant) => {
-                    let obj_len = u32::try_from(bytes.leb128_read()?)
-                        .map_err(|_| Error::msg(Error::msg("length out of u32")))?;
-                    buf.push(RawValue::U(obj_len));
-                    let mut prev_hash = None;
-                    for _ in 0..obj_len {
-                        let hash = u32::try_from(bytes.leb128_read()?)
-                            .map_err(|_| Error::msg(Error::msg("field hash out of u32")))?;
-                        if let Some(prev_hash) = prev_hash {
-                            if prev_hash >= hash {
-                                return Err(Error::msg("field id collision or not sorted"));
-                            }
-                        }
-                        prev_hash = Some(hash);
-                        buf.push(RawValue::U(hash));
-                        let ty = bytes.sleb128_read()?;
-                        validate_type_range(ty, len)?;
-                        buf.push(RawValue::I(ty));
-                    }
-                }
-                Ok(Opcode::Service) => {
-                    let obj_len = u32::try_from(bytes.leb128_read()?)
-                        .map_err(|_| Error::msg(Error::msg("length out of u32")))?;
-                    // Push one element to the table to ensure it's a non-primitive type
-                    buf.push(RawValue::U(obj_len));
-                    let mut prev = None;
-                    for _ in 0..obj_len {
-                        let mlen = bytes.leb128_read()? as usize;
-                        let meth = bytes.parse_string(mlen)?;
-                        if let Some(prev) = prev {
-                            if prev >= meth {
-                                return Err(Error::msg("method name collision or not sorted"));
-                            }
-                        }
-                        prev = Some(meth);
-                        let ty = bytes.sleb128_read()?;
-                        validate_type_range(ty, len)?;
-                        // Check for method type
-                        if ty >= 0 {
-                            let idx = ty as usize;
-                            if idx < table.len() && table[idx][0] != RawValue::I(-22) {
-                                return Err(Error::msg("not a function type"));
-                            } else {
-                                expect_func.insert(idx);
-                            }
-                        } else {
-                            return Err(Error::msg("not a function type"));
-                        }
-                    }
-                }
-                Ok(Opcode::Func) => {
-                    let arg_len = bytes.leb128_read()?;
-                    // Push one element to the table to ensure it's a non-primitive type
-                    buf.push(RawValue::U(arg_len as u32));
-                    for _ in 0..arg_len {
-                        let ty = bytes.sleb128_read()?;
-                        validate_type_range(ty, len)?;
-                    }
-                    let ret_len = bytes.leb128_read()?;
-                    for _ in 0..ret_len {
-                        let ty = bytes.sleb128_read()?;
-                        validate_type_range(ty, len)?;
-                    }
-                    let ann_len = bytes.leb128_read()?;
-                    for _ in 0..ann_len {
-                        let ann = bytes.parse_byte()?;
-                        if ann > 2u8 {
-                            return Err(Error::msg("Unknown function annotation"));
-                        }
-                    }
-                }
-                _ => {
-                    return Err(Error::msg(format!(
-                        "Unsupported op_code {} in type table",
-                        ty
-                    )))
-                }
-            };
-            table.push(buf);
-        }
-        let len = bytes.leb128_read()?;
-        for _i in 0..len {
-            let ty = bytes.sleb128_read()?;
-            validate_type_range(ty, table.len())?;
-            types.push_back(RawValue::I(ty));
-        }
-        Ok((
-            TypeTable {
-                table,
-                types,
-                current_type: VecDeque::new(),
-            },
-            bytes.0,
-        ))
-    }
-    fn pop_current_type(&mut self) -> Result<RawValue> {
-        self.current_type
-            .pop_front()
-            .ok_or_else(|| Error::msg("empty current_type"))
-    }
-    fn peek_current_type(&self) -> Result<&RawValue> {
-        self.current_type
-            .front()
-            .ok_or_else(|| Error::msg("empty current_type"))
-    }
-    fn rawvalue_to_opcode(&self, v: &RawValue) -> Result<Opcode> {
-        let mut op = v.get_i64()?;
-        if op >= 0 && op < self.table.len() as i64 {
-            op = self.table[op as usize][0].get_i64()?;
-        }
-        Opcode::try_from(op).map_err(|_| Error::msg(format!("Unknown opcode {}", op)))
-    }
-    // Pop type opcode from the front of current_type.
-    // If the opcode is an index (>= 0), we push the corresponding entry from table,
-    // to current_type queue, and pop the opcode from the front.
-    fn parse_type(&mut self) -> Result<Opcode> {
-        let mut op = self.pop_current_type()?.get_i64()?;
-        if op >= 0 && op < self.table.len() as i64 {
-            let ty = &self.table[op as usize];
-            for x in ty.iter().rev() {
-                self.current_type.push_front(x.clone());
-            }
-            op = self.pop_current_type()?.get_i64()?;
-        }
-        let r = Opcode::try_from(op).map_err(|_| Error::msg(format!("Unknown opcode {}", op)))?;
-        Ok(r)
-    }
-    // Same logic as parse_type, but not poping the current_type queue.
-    fn peek_type(&self) -> Result<Opcode> {
-        let op = self.peek_current_type()?;
-        self.rawvalue_to_opcode(op)
-    }
-    // Check if current_type matches the provided type
-    fn check_type(&mut self, expected: Opcode) -> Result<()> {
-        let wire_type = self.parse_type()?;
-        if wire_type != expected {
+macro_rules! assert {
+    ( false ) => {{
+        return Err(Error::msg(format!(
+            "Internal error at {}:{}. Please file a bug.",
+            file!(),
+            line!()
+        )));
+    }};
+    ( $pred:expr ) => {{
+        if !$pred {
             return Err(Error::msg(format!(
-                "Type mismatch. Type on the wire: {:?}; Expected type: {:?}",
-                wire_type, expected
+                "Internal error at {}:{}. Please file a bug.",
+                file!(),
+                line!()
             )));
         }
-        Ok(())
-    }
-}
-fn is_primitive_type(ty: i64) -> bool {
-    ty < 0 && (ty >= -17 || ty == -24)
-}
-fn validate_type_range(ty: i64, len: usize) -> Result<()> {
-    if ty >= 0 && (ty as usize) < len || is_primitive_type(ty) {
-        Ok(())
-    } else {
-        Err(Error::msg(format!("unknown type {}", ty)))
-    }
-}
-#[derive(Debug)]
-enum FieldLabel {
-    Named(&'static str),
-    Id(u32),
-    Variant(String),
-    Skip,
+    }};
 }
 
 struct Deserializer<'de> {
-    input: Bytes<'de>,
-    table: TypeTable,
+    input: Cursor<&'de [u8]>,
+    table: TypeEnv,
+    types: VecDeque<(usize, Type)>,
+    wire_type: Type,
+    expect_type: Type,
+    // Memo table for subtyping relation
+    gamma: Gamma,
     // field_name tells deserialize_identifier which field name to process.
     // This field should always be set by set_field_name function.
-    field_name: Option<FieldLabel>,
-    // The record nesting depth should be bounded by the length of table to avoid infinite loop.
-    record_nesting_depth: usize,
+    field_name: Option<Label>,
+    // Indicates whether to deserialize with IDLValue.
+    // It only affects the field id generation in enum type.
+    is_untyped: bool,
 }
 
 impl<'de> Deserializer<'de> {
-    fn from_bytes(input: &'de [u8]) -> Result<Self> {
-        let (table, input) = TypeTable::from_bytes(input)?;
+    fn from_bytes(bytes: &'de [u8]) -> Result<Self> {
+        let mut reader = Cursor::new(bytes);
+        let header = Header::read(&mut reader)?;
+        let (env, types) = header.to_types()?;
         Ok(Deserializer {
-            input: Bytes::from(input),
-            table,
+            input: reader,
+            table: env,
+            types: types.into_iter().enumerate().collect(),
+            wire_type: Type::Unknown,
+            expect_type: Type::Unknown,
+            gamma: Gamma::default(),
             field_name: None,
-            record_nesting_depth: 0,
+            is_untyped: false,
         })
     }
-
-    fn dump_error_state(&self, e: Error) -> Error {
-        let mut str = format!("Trailing type: {:?}\n", self.table.current_type);
-        str.push_str(&format!("Trailing value: {:02x?}\n", self.input.0));
-        if self.field_name.is_some() {
-            str.push_str(&format!("Trailing field_name: {:?}\n", self.field_name));
-        }
-        str.push_str(&format!("Type table: {:?}\n", self.table.table));
-        str.push_str(&format!("Remaining value types: {:?}", self.table.types));
-        e.with_states(str)
+    fn dump_state(&self) -> String {
+        let hex = hex::encode(self.input.get_ref());
+        let pos = self.input.position() as usize * 2;
+        let (before, after) = hex.split_at(pos);
+        let mut res = format!("input: {}_{}\n", before, after);
+        if !self.table.0.is_empty() {
+            res += &format!("table: {}", self.table);
+        }
+        res += &format!(
+            "wire_type: {}, expect_type: {}",
+            self.wire_type, self.expect_type
+        );
+        if let Some(field) = &self.field_name {
+            res += &format!(", field_name: {:?}", field);
+        }
+        res
+    }
+    fn borrow_bytes(&mut self, len: usize) -> Result<&'de [u8]> {
+        let pos = self.input.position() as usize;
+        let end = pos + len;
+        let slice = self.input.get_ref();
+        if end > slice.len() {
+            return Err(Error::msg(format!("Cannot read {} bytes", len)));
+        }
+        let res = &slice[pos..end];
+        self.input.set_position(end as u64);
+        Ok(res)
+    }
+    fn check_subtype(&mut self) -> Result<()> {
+        subtype(
+            &mut self.gamma,
+            &self.table,
+            &self.wire_type,
+            &self.table,
+            &self.expect_type,
+        )
+        .with_context(|| {
+            format!(
+                "{} is not a subtype of {}",
+                self.wire_type, self.expect_type,
+            )
+        })?;
+        Ok(())
+    }
+    fn unroll_type(&mut self) -> Result<()> {
+        self.expect_type = self.table.trace_type(&self.expect_type)?;
+        self.wire_type = self.table.trace_type(&self.wire_type)?;
+        Ok(())
     }
-
     // Should always call set_field_name to set the field_name. After deserialize_identifier
     // processed the field_name, field_name will be reset to None.
-    fn set_field_name(&mut self, field: FieldLabel) {
+    fn set_field_name(&mut self, field: Label) {
         if self.field_name.is_some() {
-            panic!("field_name already taken");
+            unreachable!();
         }
         self.field_name = Some(field);
     }
     // Customize deserailization methods
     // Several deserialize functions will call visit_byte_buf.
     // We reserve the first byte to be a tag to distinguish between different callers:
-    // int(0), nat(1), principal(2), reserved(3)
+    // int(0), nat(1), principal(2), reserved(3), service(4), function(5)
     // This is necessary for deserializing IDLValue because
     // it has only one visitor and we need a way to know who called the visitor.
     fn deserialize_int<'a, V>(&'a mut self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        self.record_nesting_depth = 0;
-        self.table.check_type(Opcode::Int)?;
-        let v = Int::decode(&mut self.input.0).map_err(Error::msg)?;
-        let bytes = v.0.to_signed_bytes_le();
-        let mut tagged = vec![0u8];
-        tagged.extend_from_slice(&bytes);
-        visitor.visit_byte_buf(tagged)
+        use std::convert::TryInto;
+        assert!(self.expect_type == Type::Int);
+        let mut bytes = vec![0u8];
+        let int = match &self.wire_type {
+            Type::Int => Int::decode(&mut self.input).map_err(Error::msg)?,
+            Type::Nat => Int(Nat::decode(&mut self.input)
+                .map_err(Error::msg)?
+                .0
+                .try_into()
+                .map_err(Error::msg)?),
+            // We already did subtype checking before deserialize, so this is unreachable code
+            _ => assert!(false),
+        };
+        bytes.extend_from_slice(&int.0.to_signed_bytes_le());
+        visitor.visit_byte_buf(bytes)
     }
     fn deserialize_nat<'a, V>(&'a mut self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        self.record_nesting_depth = 0;
-        self.table.check_type(Opcode::Nat)?;
-        let v = Nat::decode(&mut self.input.0).map_err(Error::msg)?;
-        let bytes = v.0.to_bytes_le();
-        let mut tagged = vec![1u8];
-        tagged.extend_from_slice(&bytes);
-        visitor.visit_byte_buf(tagged)
-    }
-    fn decode_principal(&mut self) -> Result<Vec<u8>> {
-        let bit = self.input.parse_byte()?;
-        if bit != 1u8 {
-            return Err(Error::msg("Opaque reference not supported"));
-        }
-        let len = self.input.leb128_read()? as usize;
-        self.input.parse_bytes(len)
+        assert!(self.expect_type == Type::Nat && self.wire_type == Type::Nat);
+        let mut bytes = vec![1u8];
+        let nat = Nat::decode(&mut self.input).map_err(Error::msg)?;
+        bytes.extend_from_slice(&nat.0.to_bytes_le());
+        visitor.visit_byte_buf(bytes)
     }
     fn deserialize_principal<'a, V>(&'a mut self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        self.record_nesting_depth = 0;
-        self.table.check_type(Opcode::Principal)?;
-        let vec = self.decode_principal()?;
-        let mut tagged = vec![2u8];
-        tagged.extend_from_slice(&vec);
-        visitor.visit_byte_buf(tagged)
+        assert!(self.expect_type == Type::Principal && self.wire_type == Type::Principal);
+        let mut bytes = vec![2u8];
+        let id = PrincipalBytes::read(&mut self.input)?.inner;
+        bytes.extend_from_slice(&id);
+        visitor.visit_byte_buf(bytes)
     }
-    fn deserialize_service<'a, V>(&'a mut self, visitor: V) -> Result<V::Value>
+    fn deserialize_reserved<'a, V>(&'a mut self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        self.record_nesting_depth = 0;
-        self.table.check_type(Opcode::Service)?;
-        self.table.pop_current_type()?;
-        let vec = self.decode_principal()?;
-        let mut tagged = vec![4u8];
-        tagged.extend_from_slice(&vec);
-        visitor.visit_byte_buf(tagged)
+        let bytes = vec![3u8];
+        visitor.visit_byte_buf(bytes)
     }
-    fn deserialize_function<'a, V>(&'a mut self, visitor: V) -> Result<V::Value>
+    fn deserialize_service<'a, V>(&'a mut self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        self.record_nesting_depth = 0;
-        self.table.check_type(Opcode::Func)?;
-        self.table.pop_current_type()?;
-        let bit = self.input.parse_byte()?;
-        if bit != 1u8 {
-            return Err(Error::msg("Opaque reference not supported"));
-        }
-        let vec = self.decode_principal()?;
-        let len = self.input.leb128_read()? as usize;
-        let meth = self.input.parse_bytes(len)?;
-        let mut tagged = vec![5u8];
-        // TODO: find a better way
-        leb128::write::unsigned(&mut tagged, len as u64)?;
-        tagged.extend_from_slice(&meth);
-        tagged.extend_from_slice(&vec);
-        visitor.visit_byte_buf(tagged)
+        self.unroll_type()?;
+        assert!(matches!(self.wire_type, Type::Service(_)));
+        let mut bytes = vec![4u8];
+        let id = PrincipalBytes::read(&mut self.input)?.inner;
+        bytes.extend_from_slice(&id);
+        visitor.visit_byte_buf(bytes)
     }
-    fn deserialize_reserved<'a, V>(&'a mut self, visitor: V) -> Result<V::Value>
+    fn deserialize_function<'a, V>(&'a mut self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        self.record_nesting_depth = 0;
-        self.table.check_type(Opcode::Reserved)?;
-        let tagged = vec![3u8];
-        visitor.visit_byte_buf(tagged)
+        self.unroll_type()?;
+        assert!(matches!(self.wire_type, Type::Func(_)));
+        if !BoolValue::read(&mut self.input)?.0 {
+            return Err(Error::msg("Opaque reference not supported"));
+        }
+        let mut bytes = vec![5u8];
+        let id = PrincipalBytes::read(&mut self.input)?.inner;
+        let len = Len::read(&mut self.input)?.0;
+        let meth = self.borrow_bytes(len)?;
+        // TODO find a better way
+        leb128::write::unsigned(&mut bytes, len as u64)?;
+        bytes.extend_from_slice(meth);
+        bytes.extend_from_slice(&id);
+        visitor.visit_byte_buf(bytes)
     }
     fn deserialize_empty<'a, V>(&'a mut self, _visitor: V) -> Result<V::Value>
     where
@@ -455,14 +308,14 @@ impl<'de> Deserializer<'de> {
 }
 
 macro_rules! primitive_impl {
-    ($ty:ident, $opcode:expr, $($value:tt)*) => {
+    ($ty:ident, $type:expr, $($value:tt)*) => {
         paste::item! {
             fn [<deserialize_ $ty>]<V>(self, visitor: V) -> Result<V::Value>
             where V: Visitor<'de> {
-                self.record_nesting_depth = 0;
-                self.table.check_type($opcode)?;
-                let value = (self.input.0).$($value)*().map_err(|_| Error::msg(format!("cannot read {} value", stringify!($opcode))))?;
-                visitor.[<visit_ $ty>](value)
+                assert!(self.expect_type == $type && self.wire_type == $type);
+                let val = self.input.$($value)*().map_err(|_| Error::msg(format!("Cannot read {} value", stringify!($type))))?;
+                //let val: $ty = self.input.read_le()?;
+                visitor.[<visit_ $ty>](val)
             }
         }
     };
@@ -470,304 +323,277 @@ macro_rules! primitive_impl {
 
 impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     type Error = Error;
-
-    // Skipping unused field types
-    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
         if self.field_name.is_some() {
             return self.deserialize_identifier(visitor);
         }
-        let t = self.table.peek_type()?;
-        if t != Opcode::Record {
-            self.record_nesting_depth = 0;
-        }
+        let t = self.table.trace_type(&self.expect_type)?;
         match t {
-            Opcode::Int => self.deserialize_int(visitor),
-            Opcode::Nat => self.deserialize_nat(visitor),
-            Opcode::Nat8 => self.deserialize_u8(visitor),
-            Opcode::Nat16 => self.deserialize_u16(visitor),
-            Opcode::Nat32 => self.deserialize_u32(visitor),
-            Opcode::Nat64 => self.deserialize_u64(visitor),
-            Opcode::Int8 => self.deserialize_i8(visitor),
-            Opcode::Int16 => self.deserialize_i16(visitor),
-            Opcode::Int32 => self.deserialize_i32(visitor),
-            Opcode::Int64 => self.deserialize_i64(visitor),
-            Opcode::Float32 => self.deserialize_f32(visitor),
-            Opcode::Float64 => self.deserialize_f64(visitor),
-            Opcode::Bool => self.deserialize_bool(visitor),
-            Opcode::Text => self.deserialize_string(visitor),
-            Opcode::Null => self.deserialize_unit(visitor),
-            Opcode::Reserved => self.deserialize_reserved(visitor),
-            Opcode::Empty => self.deserialize_empty(visitor),
-            Opcode::Vec => self.deserialize_seq(visitor),
-            Opcode::Opt => self.deserialize_option(visitor),
-            Opcode::Record => self.deserialize_struct("_", &[], visitor),
-            Opcode::Variant => self.deserialize_enum("_", &[], visitor),
-            Opcode::Principal => self.deserialize_principal(visitor),
-            Opcode::Service => self.deserialize_service(visitor),
-            Opcode::Func => self.deserialize_function(visitor),
+            Type::Int => self.deserialize_int(visitor),
+            Type::Nat => self.deserialize_nat(visitor),
+            Type::Nat8 => self.deserialize_u8(visitor),
+            Type::Nat16 => self.deserialize_u16(visitor),
+            Type::Nat32 => self.deserialize_u32(visitor),
+            Type::Nat64 => self.deserialize_u64(visitor),
+            Type::Int8 => self.deserialize_i8(visitor),
+            Type::Int16 => self.deserialize_i16(visitor),
+            Type::Int32 => self.deserialize_i32(visitor),
+            Type::Int64 => self.deserialize_i64(visitor),
+            Type::Float32 => self.deserialize_f32(visitor),
+            Type::Float64 => self.deserialize_f64(visitor),
+            Type::Bool => self.deserialize_bool(visitor),
+            Type::Text => self.deserialize_string(visitor),
+            Type::Null => self.deserialize_unit(visitor),
+            Type::Reserved => {
+                if self.wire_type != Type::Reserved {
+                    self.deserialize_ignored_any(serde::de::IgnoredAny)?;
+                }
+                self.deserialize_reserved(visitor)
+            }
+            Type::Empty => self.deserialize_empty(visitor),
+            Type::Principal => self.deserialize_principal(visitor),
+            // construct types
+            Type::Opt(_) => self.deserialize_option(visitor),
+            Type::Vec(_) => self.deserialize_seq(visitor),
+            Type::Record(_) => self.deserialize_struct("_", &[], visitor),
+            Type::Variant(_) => self.deserialize_enum("_", &[], visitor),
+            Type::Service(_) => self.deserialize_service(visitor),
+            Type::Func(_) => self.deserialize_function(visitor),
+            _ => assert!(false),
         }
     }
-
-    // Used for deserializing to IDLValue
-    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value>
+    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        if self.field_name.is_some() {
-            return self.deserialize_identifier(visitor);
-        }
-        let t = self.table.peek_type()?;
-        if t != Opcode::Record {
-            self.record_nesting_depth = 0;
-        }
-        match t {
-            Opcode::Int => self.deserialize_int(visitor),
-            Opcode::Nat => self.deserialize_nat(visitor),
-            Opcode::Nat8 => self.deserialize_u8(visitor),
-            Opcode::Nat16 => self.deserialize_u16(visitor),
-            Opcode::Nat32 => self.deserialize_u32(visitor),
-            Opcode::Nat64 => self.deserialize_u64(visitor),
-            Opcode::Int8 => self.deserialize_i8(visitor),
-            Opcode::Int16 => self.deserialize_i16(visitor),
-            Opcode::Int32 => self.deserialize_i32(visitor),
-            Opcode::Int64 => self.deserialize_i64(visitor),
-            Opcode::Float32 => self.deserialize_f32(visitor),
-            Opcode::Float64 => self.deserialize_f64(visitor),
-            Opcode::Bool => self.deserialize_bool(visitor),
-            Opcode::Text => self.deserialize_string(visitor),
-            Opcode::Null => self.deserialize_unit(visitor),
-            Opcode::Reserved => self.deserialize_reserved(visitor),
-            Opcode::Empty => self.deserialize_empty(visitor),
-            Opcode::Vec => self.deserialize_seq(visitor),
-            Opcode::Opt => self.deserialize_option(visitor),
-            Opcode::Record => {
-                let old_nesting = self.record_nesting_depth;
-                self.record_nesting_depth += 1;
-                if self.record_nesting_depth > self.table.table.len() {
-                    return Err(Error::msg("There is an infinite loop in the record definition, the type is isomorphic to an empty type"));
-                }
-                self.table.check_type(Opcode::Record)?;
-                let len = self.table.pop_current_type()?.get_u32()?;
-                let mut fs = BTreeMap::new();
-                for i in 0..len {
-                    let hash = self.table.current_type[2 * i as usize].get_u32()?;
-                    if fs.insert(hash, None) != None {
-                        return Err(Error::msg(format!("hash collision {}", hash)));
-                    }
-                }
-                let res = visitor.visit_map(Compound::new(&mut self, Style::Struct { len, fs }));
-                self.record_nesting_depth = old_nesting;
-                res
-            }
-            Opcode::Variant => {
-                self.record_nesting_depth = 0;
-                self.table.check_type(Opcode::Variant)?;
-                let len = self.table.pop_current_type()?.get_u32()?;
-                let mut fs = BTreeMap::new();
-                for i in 0..len {
-                    let hash = self.table.current_type[2 * i as usize].get_u32()?;
-                    if fs.insert(hash, None) != None {
-                        return Err(Error::msg(format!("hash collision {}", hash)));
-                    }
-                }
-                visitor.visit_enum(Compound::new(&mut self, Style::Enum { len, fs }))
-            }
-            Opcode::Principal => self.deserialize_principal(visitor),
-            Opcode::Service => self.deserialize_service(visitor),
-            Opcode::Func => self.deserialize_function(visitor),
-        }
+        self.expect_type = self.wire_type.clone();
+        self.deserialize_any(visitor)
     }
 
-    primitive_impl!(i8, Opcode::Int8, read_i8);
-    primitive_impl!(i16, Opcode::Int16, read_i16::<LittleEndian>);
-    primitive_impl!(i32, Opcode::Int32, read_i32::<LittleEndian>);
-    primitive_impl!(i64, Opcode::Int64, read_i64::<LittleEndian>);
-    primitive_impl!(u8, Opcode::Nat8, read_u8);
-    primitive_impl!(u16, Opcode::Nat16, read_u16::<LittleEndian>);
-    primitive_impl!(u32, Opcode::Nat32, read_u32::<LittleEndian>);
-    primitive_impl!(u64, Opcode::Nat64, read_u64::<LittleEndian>);
-    primitive_impl!(f32, Opcode::Float32, read_f32::<LittleEndian>);
-    primitive_impl!(f64, Opcode::Float64, read_f64::<LittleEndian>);
+    primitive_impl!(i8, Type::Int8, read_i8);
+    primitive_impl!(i16, Type::Int16, read_i16::<LittleEndian>);
+    primitive_impl!(i32, Type::Int32, read_i32::<LittleEndian>);
+    primitive_impl!(i64, Type::Int64, read_i64::<LittleEndian>);
+    primitive_impl!(u8, Type::Nat8, read_u8);
+    primitive_impl!(u16, Type::Nat16, read_u16::<LittleEndian>);
+    primitive_impl!(u32, Type::Nat32, read_u32::<LittleEndian>);
+    primitive_impl!(u64, Type::Nat64, read_u64::<LittleEndian>);
+    primitive_impl!(f32, Type::Float32, read_f32::<LittleEndian>);
+    primitive_impl!(f64, Type::Float64, read_f64::<LittleEndian>);
 
     fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
         use std::convert::TryInto;
-        self.record_nesting_depth = 0;
-        let value: i128 = match self.table.parse_type()? {
-            Opcode::Int => {
-                let v = Int::decode(&mut self.input.0).map_err(Error::msg)?;
-                v.0.try_into().map_err(Error::msg)?
-            }
-            Opcode::Nat => {
-                let v = Nat::decode(&mut self.input.0).map_err(Error::msg)?;
-                v.0.try_into().map_err(Error::msg)?
+        assert!(self.expect_type == Type::Int);
+        let value: i128 = match &self.wire_type {
+            Type::Int => {
+                let int = Int::decode(&mut self.input).map_err(Error::msg)?;
+                int.0.try_into().map_err(Error::msg)?
             }
-            t => {
-                return Err(Error::msg(format!(
-                    "Type mismatch. Type on the wire: {:?}; Expected type: int",
-                    t
-                )))
+            Type::Nat => {
+                let nat = Nat::decode(&mut self.input).map_err(Error::msg)?;
+                nat.0.try_into().map_err(Error::msg)?
             }
+            _ => assert!(false),
         };
         visitor.visit_i128(value)
     }
-
     fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
         use std::convert::TryInto;
-        self.record_nesting_depth = 0;
-        self.table.check_type(Opcode::Nat)?;
-        let v = Nat::decode(&mut self.input.0).map_err(Error::msg)?;
-        let value: u128 = v.0.try_into().map_err(Error::msg)?;
+        assert!(self.expect_type == Type::Nat && self.wire_type == Type::Nat);
+        let nat = Nat::decode(&mut self.input).map_err(Error::msg)?;
+        let value: u128 = nat.0.try_into().map_err(Error::msg)?;
         visitor.visit_u128(value)
     }
-
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        assert!(self.expect_type == Type::Null && self.wire_type == Type::Null);
+        visitor.visit_unit()
+    }
     fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        self.record_nesting_depth = 0;
-        self.table.check_type(Opcode::Bool)?;
-        let byte = self.input.parse_byte()?;
-        if byte > 1u8 {
-            return Err(de::Error::custom("not a boolean value"));
-        }
-        let value = byte == 1u8;
-        visitor.visit_bool(value)
+        assert!(self.expect_type == Type::Bool && self.wire_type == Type::Bool);
+        let res = BoolValue::read(&mut self.input)?;
+        visitor.visit_bool(res.0)
     }
-
     fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        self.record_nesting_depth = 0;
-        self.table.check_type(Opcode::Text)?;
-        let len = self.input.leb128_read()? as usize;
-        let value = self.input.parse_string(len)?;
+        assert!(self.expect_type == Type::Text && self.wire_type == Type::Text);
+        let len = Len::read(&mut self.input)?.0;
+        let bytes = self.borrow_bytes(len)?.to_owned();
+        let value = String::from_utf8(bytes).map_err(Error::msg)?;
         visitor.visit_string(value)
     }
-
     fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        self.record_nesting_depth = 0;
-        self.table.check_type(Opcode::Text)?;
-        let len = self.input.leb128_read()? as usize;
-        let value: Result<&str> =
-            std::str::from_utf8(&self.input.0[0..len]).map_err(de::Error::custom);
-        self.input.0 = &self.input.0[len..];
-        visitor.visit_borrowed_str(value?)
+        assert!(self.expect_type == Type::Text && self.wire_type == Type::Text);
+        let len = Len::read(&mut self.input)?.0;
+        let slice = self.borrow_bytes(len)?;
+        let value: &str = std::str::from_utf8(slice).map_err(Error::msg)?;
+        visitor.visit_borrowed_str(value)
     }
-
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
+    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        self.record_nesting_depth = 0;
-        match self.table.peek_type()? {
-            Opcode::Opt => {
-                self.table.parse_type()?;
-                match self.input.parse_byte()? {
-                    0 => {
-                        // Skip the type T of Option<T>
-                        self.table.pop_current_type()?;
-                        visitor.visit_none()
-                    }
-                    // TODO handle subtyping failure
-                    1 => visitor.visit_some(self),
-                    _ => Err(de::Error::custom("not an option tag")),
-                }
-            }
-            Opcode::Null | Opcode::Reserved => {
-                self.table.parse_type()?;
-                visitor.visit_none()
-            }
-            _ => visitor.visit_some(self),
-        }
+        self.deserialize_unit(visitor)
     }
-    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
+    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        self.record_nesting_depth = 0;
-        self.table.check_type(Opcode::Null)?;
-        visitor.visit_unit()
+        visitor.visit_newtype_struct(self)
     }
-    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        self.deserialize_unit(visitor)
+        self.unroll_type()?;
+        match (&self.wire_type, &self.expect_type) {
+            (Type::Null, Type::Opt(_)) | (Type::Reserved, Type::Opt(_)) => visitor.visit_none(),
+            (Type::Opt(t1), Type::Opt(t2)) => {
+                self.wire_type = *t1.clone();
+                self.expect_type = *t2.clone();
+                if BoolValue::read(&mut self.input)?.0 {
+                    if self.check_subtype().is_ok() {
+                        visitor.visit_some(self)
+                    } else {
+                        self.deserialize_ignored_any(serde::de::IgnoredAny)?;
+                        visitor.visit_none()
+                    }
+                } else {
+                    visitor.visit_none()
+                }
+            }
+            (_, Type::Opt(t2)) => {
+                self.expect_type = self.table.trace_type(&*t2)?;
+                if !matches!(self.expect_type, Type::Null | Type::Reserved | Type::Opt(_))
+                    && self.check_subtype().is_ok()
+                {
+                    visitor.visit_some(self)
+                } else {
+                    self.deserialize_ignored_any(serde::de::IgnoredAny)?;
+                    visitor.visit_none()
+                }
+            }
+            (_, _) => assert!(false),
+        }
     }
-    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
+    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        visitor.visit_newtype_struct(self)
+        self.unroll_type()?;
+        match (&self.expect_type, &self.wire_type) {
+            (Type::Vec(ref e), Type::Vec(ref w)) => {
+                let expect = *e.clone();
+                let wire = *w.clone();
+                let len = Len::read(&mut self.input)?.0;
+                visitor.visit_seq(Compound::new(
+                    &mut self,
+                    Style::Vector { len, expect, wire },
+                ))
+            }
+            (Type::Record(e), Type::Record(w)) => {
+                let expect = e.clone().into();
+                let wire = w.clone().into();
+                assert!(self.expect_type.is_tuple());
+                if !self.wire_type.is_tuple() {
+                    return Err(Error::msg(format!(
+                        "{} is not a tuple type",
+                        self.wire_type
+                    )));
+                }
+                let value =
+                    visitor.visit_seq(Compound::new(&mut self, Style::Struct { expect, wire }))?;
+                Ok(value)
+            }
+            (Type::Record(_), Type::Empty) => Err(Error::msg("Cannot decode empty type")),
+            _ => assert!(false),
+        }
     }
     fn deserialize_byte_buf<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
-        self.record_nesting_depth = 0;
-        self.table.check_type(Opcode::Vec)?;
-        self.table.check_type(Opcode::Nat8)?;
-        let len = self.input.leb128_read()?;
-        let bytes = self.input.parse_bytes(len as usize)?;
+        self.unroll_type()?;
+        assert!(
+            self.expect_type == Type::Vec(Box::new(Type::Nat8))
+                && self.wire_type == Type::Vec(Box::new(Type::Nat8))
+        );
+        let len = Len::read(&mut self.input)?.0;
+        let bytes = self.borrow_bytes(len)?.to_owned();
+        //let bytes = Bytes::read(&mut self.input)?.inner;
         visitor.visit_byte_buf(bytes)
     }
     fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
-        self.record_nesting_depth = 0;
-        match self.table.peek_type()? {
-            Opcode::Principal => self.deserialize_principal(visitor),
-            Opcode::Vec => {
-                self.table.check_type(Opcode::Vec)?;
-                self.table.check_type(Opcode::Nat8)?;
-                let len = self.input.leb128_read()? as usize;
-                let bytes: &[u8] = &self.input.0[0..len];
-                self.input.0 = &self.input.0[len..];
-                visitor.visit_borrowed_bytes(bytes)
+        self.unroll_type()?;
+        match &self.expect_type {
+            Type::Principal => self.deserialize_principal(visitor),
+            Type::Vec(t) if **t == Type::Nat8 => {
+                let len = Len::read(&mut self.input)?.0;
+                let slice = self.borrow_bytes(len)?;
+                visitor.visit_borrowed_bytes(slice)
             }
             _ => Err(Error::msg("bytes only takes principal or vec nat8")),
         }
     }
-    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value>
+    fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        self.record_nesting_depth = 0;
-        match self.table.parse_type()? {
-            Opcode::Vec => {
-                let len = self.input.leb128_read()?;
-                let value = visitor.visit_seq(Compound::new(&mut self, Style::Vector { len }));
-                // Skip the type T of Vec<T>.
-                self.table.pop_current_type()?;
-                value
-            }
-            Opcode::Record => {
-                let len = self.table.pop_current_type()?.get_u32()?;
-                visitor.visit_seq(Compound::new(&mut self, Style::Tuple { len, index: 0 }))
+        self.unroll_type()?;
+        match (&self.expect_type, &self.wire_type) {
+            (Type::Vec(ref e), Type::Vec(ref w)) => {
+                let e = self.table.trace_type(e)?;
+                let w = self.table.trace_type(w)?;
+                let len = Len::read(&mut self.input)?.0;
+                match (e, w) {
+                    (Type::Record(ref e), Type::Record(ref w)) => match (&e[..], &w[..]) {
+                        (
+                            [Field {
+                                id: Label::Id(0),
+                                ty: ek,
+                            }, Field {
+                                id: Label::Id(1),
+                                ty: ev,
+                            }],
+                            [Field {
+                                id: Label::Id(0),
+                                ty: wk,
+                            }, Field {
+                                id: Label::Id(1),
+                                ty: wv,
+                            }],
+                        ) => {
+                            let expect = (ek.clone(), ev.clone());
+                            let wire = (wk.clone(), wv.clone());
+                            visitor.visit_map(Compound::new(
+                                &mut self,
+                                Style::Map { len, expect, wire },
+                            ))
+                        }
+                        _ => Err(Error::msg("expect a key-value pair")),
+                    },
+                    _ => Err(Error::msg("expect a key-value pair")),
+                }
             }
-            _ => Err(Error::msg("seq only takes vector or tuple")),
+            _ => assert!(false),
         }
     }
-    fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value>
-    where
-        V: Visitor<'de>,
-    {
-        self.record_nesting_depth = 0;
-        self.table.check_type(Opcode::Vec)?;
-        let len = self.input.leb128_read()?;
-        let ty = self.table.peek_current_type()?.clone();
-        let value = visitor.visit_map(Compound::new(&mut self, Style::Map { len, ty }));
-        self.table.pop_current_type()?;
-        value
-    }
     fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
@@ -788,68 +614,74 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     fn deserialize_struct<V>(
         mut self,
         _name: &'static str,
-        fields: &'static [&'static str],
+        _fields: &'static [&'static str],
         visitor: V,
     ) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        let old_nesting = self.record_nesting_depth;
-        self.record_nesting_depth += 1;
-        if self.record_nesting_depth > self.table.table.len() {
-            return Err(Error::msg("There is an infinite loop in the record definition, the type is isomorphic to an empty type"));
-        }
-        self.table.check_type(Opcode::Record)?;
-        let len = self.table.pop_current_type()?.get_u32()?;
-        let mut fs = BTreeMap::new();
-        for s in fields.iter() {
-            if fs.insert(idl_hash(s), Some(*s)) != None {
-                return Err(Error::msg(format!("hash collision {}", s)));
+        self.unroll_type()?;
+        match (&self.expect_type, &self.wire_type) {
+            (Type::Record(e), Type::Record(w)) => {
+                let expect = e.clone().into();
+                let wire = w.clone().into();
+                let value =
+                    visitor.visit_map(Compound::new(&mut self, Style::Struct { expect, wire }))?;
+                Ok(value)
             }
+            (Type::Record(_), Type::Empty) => Err(Error::msg("Cannot decode empty type")),
+            _ => assert!(false),
         }
-        let value = visitor.visit_map(Compound::new(&mut self, Style::Struct { len, fs }))?;
-        self.record_nesting_depth = old_nesting;
-        Ok(value)
     }
-
     fn deserialize_enum<V>(
         mut self,
         _name: &'static str,
-        variants: &'static [&'static str],
+        _variants: &'static [&'static str],
         visitor: V,
     ) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        self.record_nesting_depth = 0;
-        self.table.check_type(Opcode::Variant)?;
-        let len = self.table.pop_current_type()?.get_u32()?;
-        let mut fs = BTreeMap::new();
-        for s in variants.iter() {
-            if fs.insert(idl_hash(s), Some(*s)) != None {
-                return Err(Error::msg(format!("hash collision {}", s)));
+        self.unroll_type()?;
+        match (&self.expect_type, &self.wire_type) {
+            (Type::Variant(e), Type::Variant(w)) => {
+                let index = Len::read(&mut self.input)?.0;
+                let len = w.len();
+                if index >= len {
+                    return Err(Error::msg(format!(
+                        "Variant index {} larger than length {}",
+                        index, len
+                    )));
+                }
+                let wire = w[index].clone();
+                let e_tuple = e
+                    .iter()
+                    .enumerate()
+                    .find(|(_, ref f)| f.id == wire.id)
+                    .ok_or_else(|| Error::msg(format!("Unknown variant field {}", wire.id)))?;
+                let expect_index = e_tuple.0;
+                let expect = e_tuple.1.clone();
+                visitor.visit_enum(Compound::new(
+                    &mut self,
+                    Style::Enum {
+                        expect,
+                        expect_index,
+                        wire,
+                    },
+                ))
             }
+            _ => assert!(false),
         }
-        let value = visitor.visit_enum(Compound::new(&mut self, Style::Enum { len, fs }))?;
-        Ok(value)
     }
-    /// Deserialize identifier.
-    /// # Panics
-    /// *Will Panic* when identifier name is None.
     fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        // N.B. Here we want to panic as it indicates a logical error.
-        let label = self.field_name.as_ref().unwrap();
-        let v = match label {
-            FieldLabel::Named(name) => visitor.visit_str(name),
-            FieldLabel::Id(hash) => visitor.visit_u32(*hash),
-            FieldLabel::Variant(variant) => visitor.visit_str(variant),
-            FieldLabel::Skip => visitor.visit_str("_"),
-        };
-        self.field_name = None;
-        v
+        match self.field_name.take() {
+            Some(Label::Named(name)) => visitor.visit_string(name),
+            Some(Label::Id(hash)) | Some(Label::Unnamed(hash)) => visitor.visit_u32(hash),
+            None => assert!(false),
+        }
     }
 
     serde::forward_to_deserialize_any! {
@@ -859,24 +691,24 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
 
 #[derive(Debug)]
 enum Style {
-    Tuple {
-        len: u32,
-        index: u32,
-    },
     Vector {
-        len: u64, // non-vector length can only be u32, because field ids is u32.
+        len: usize,
+        expect: Type,
+        wire: Type,
     },
     Struct {
-        len: u32,
-        fs: BTreeMap<u32, Option<&'static str>>,
+        expect: VecDeque<Field>,
+        wire: VecDeque<Field>,
     },
     Enum {
-        len: u32,
-        fs: BTreeMap<u32, Option<&'static str>>,
+        expect: Field,
+        expect_index: usize,
+        wire: Field,
     },
     Map {
-        len: u64,
-        ty: RawValue,
+        len: usize,
+        expect: (Type, Type),
+        wire: (Type, Type),
     },
 }
 
@@ -899,30 +731,28 @@ impl<'de, 'a> de::SeqAccess<'de> for Compound<'a, 'de> {
         T: de::DeserializeSeed<'de>,
     {
         match self.style {
-            Style::Tuple {
-                ref len,
-                ref mut index,
+            Style::Vector {
+                ref mut len,
+                ref expect,
+                ref wire,
             } => {
-                if *index == *len {
+                if *len == 0 {
                     return Ok(None);
                 }
-                let t_idx = self.de.table.pop_current_type()?.get_u32()?;
-                if t_idx != *index {
-                    return Err(Error::msg(format!(
-                        "Expect vector index {}, but get {}",
-                        index, t_idx
-                    )));
-                }
-                *index += 1;
+                *len -= 1;
+                self.de.expect_type = expect.clone();
+                self.de.wire_type = wire.clone();
                 seed.deserialize(&mut *self.de).map(Some)
             }
-            Style::Vector { ref mut len } => {
-                if *len == 0 {
+            Style::Struct {
+                ref mut expect,
+                ref mut wire,
+            } => {
+                if expect.is_empty() && wire.is_empty() {
                     return Ok(None);
                 }
-                let ty = self.de.table.peek_current_type()?.clone();
-                self.de.table.current_type.push_front(ty);
-                *len -= 1;
+                self.de.expect_type = expect.pop_front().map(|f| f.ty).unwrap_or(Type::Reserved);
+                self.de.wire_type = wire.pop_front().map(|f| f.ty).unwrap_or(Type::Reserved);
                 seed.deserialize(&mut *self.de).map(Some)
             }
             _ => Err(Error::msg("expect vector or tuple")),
@@ -938,33 +768,56 @@ impl<'de, 'a> de::MapAccess<'de> for Compound<'a, 'de> {
     {
         match self.style {
             Style::Struct {
-                ref mut len,
-                ref fs,
+                ref mut expect,
+                ref mut wire,
             } => {
-                if *len == 0 {
-                    return Ok(None);
-                }
-                *len -= 1;
-                let hash = self.de.table.pop_current_type()?.get_u32()?;
-                match fs.get(&hash) {
-                    Some(None) => self.de.set_field_name(FieldLabel::Id(hash)),
-                    Some(Some(field)) => self.de.set_field_name(FieldLabel::Named(field)),
-                    None => {
-                        // This triggers seed.deserialize to call deserialize_ignore_any
-                        // to skip both type and value of this unknown field.
-                        self.de.set_field_name(FieldLabel::Skip);
+                match (expect.front(), wire.front()) {
+                    (Some(e), Some(w)) => {
+                        use std::cmp::Ordering;
+                        match e.id.get_id().cmp(&w.id.get_id()) {
+                            Ordering::Equal => {
+                                self.de.set_field_name(e.id.clone());
+                                self.de.expect_type = expect.pop_front().unwrap().ty;
+                                self.de.wire_type = wire.pop_front().unwrap().ty;
+                            }
+                            Ordering::Less => {
+                                // by subtyping rules, expect_type can only be opt, reserved or null.
+                                self.de.set_field_name(e.id.clone());
+                                self.de.expect_type = expect.pop_front().unwrap().ty;
+                                self.de.wire_type = Type::Reserved;
+                            }
+                            Ordering::Greater => {
+                                self.de.set_field_name(Label::Named("_".to_owned()));
+                                self.de.wire_type = wire.pop_front().unwrap().ty;
+                                self.de.expect_type = Type::Reserved;
+                            }
+                        }
+                    }
+                    (None, Some(_)) => {
+                        self.de.set_field_name(Label::Named("_".to_owned()));
+                        self.de.wire_type = wire.pop_front().unwrap().ty;
+                        self.de.expect_type = Type::Reserved;
                     }
+                    (Some(e), None) => {
+                        self.de.set_field_name(e.id.clone());
+                        self.de.expect_type = expect.pop_front().unwrap().ty;
+                        self.de.wire_type = Type::Reserved;
+                    }
+                    (None, None) => return Ok(None),
                 }
                 seed.deserialize(&mut *self.de).map(Some)
             }
-            Style::Map { ref mut len, .. } => {
+            Style::Map {
+                ref mut len,
+                ref expect,
+                ref wire,
+            } => {
                 // This only comes from deserialize_map
                 if *len == 0 {
                     return Ok(None);
                 }
-                self.de.table.check_type(Opcode::Record)?;
-                assert_eq!(2, self.de.table.pop_current_type()?.get_u32()?);
-                assert_eq!(0, self.de.table.pop_current_type()?.get_u32()?);
+                self.de.expect_type = expect.0.clone();
+                self.de.wire_type = wire.0.clone();
                 *len -= 1;
                 seed.deserialize(&mut *self.de).map(Some)
             }
@@ -975,12 +828,11 @@ impl<'de, 'a> de::MapAccess<'de> for Compound<'a, 'de> {
     where
         V: de::DeserializeSeed<'de>,
     {
-        match self.style {
-            Style::Map { ref ty, .. } => {
-                assert_eq!(1, self.de.table.pop_current_type()?.get_u32()?);
-                let res = seed.deserialize(&mut *self.de);
-                self.de.table.current_type.push_front(ty.clone());
-                res
+        match &self.style {
+            Style::Map { expect, wire, .. } => {
+                self.de.expect_type = expect.1.clone();
+                self.de.wire_type = wire.1.clone();
+                seed.deserialize(&mut *self.de)
             }
             _ => seed.deserialize(&mut *self.de),
         }
@@ -995,57 +847,29 @@ impl<'de, 'a> de::EnumAccess<'de> for Compound<'a, 'de> {
     where
         V: de::DeserializeSeed<'de>,
     {
-        match self.style {
-            Style::Enum { len, ref fs } => {
-                let index = u32::try_from(self.de.input.leb128_read()?)
-                    .map_err(|_| Error::msg("variant index out of u32"))?;
-                if index >= len {
-                    return Err(Error::msg(format!(
-                        "variant index {} larger than length {}",
-                        index, len
-                    )));
-                }
-                let mut index_ty = None;
-                for i in 0..len {
-                    let hash = self.de.table.pop_current_type()?.get_u32()?;
-                    let ty = self.de.table.pop_current_type()?;
-                    if i == index {
-                        match fs.get(&hash) {
-                            Some(None) => {
-                                let opcode = self.de.table.rawvalue_to_opcode(&ty)?;
-                                let accessor = match opcode {
-                                    Opcode::Null => "unit",
-                                    Opcode::Record => "struct",
-                                    _ => "newtype",
-                                };
-                                self.de.set_field_name(FieldLabel::Variant(format!(
-                                    "{},{}",
-                                    hash, accessor
-                                )));
-                            }
-                            Some(Some(field)) => {
-                                self.de.set_field_name(FieldLabel::Named(field));
-                            }
-                            None => {
-                                if !fs.is_empty() {
-                                    return Err(Error::msg(format!(
-                                        "Unknown variant hash {}",
-                                        hash
-                                    )));
-                                } else {
-                                    // Actual enum won't have empty fs. This can only be generated
-                                    // from deserialize_ignored_any
-                                    self.de.set_field_name(FieldLabel::Skip);
-                                }
-                            }
-                        }
-                        index_ty = Some(ty);
-                    }
+        match &self.style {
+            Style::Enum {
+                expect,
+                expect_index,
+                wire,
+            } => {
+                self.de.expect_type = expect.ty.clone();
+                self.de.wire_type = wire.ty.clone();
+                let (mut label, label_type) = match &expect.id {
+                    Label::Named(name) => (name.clone(), "name"),
+                    Label::Id(hash) | Label::Unnamed(hash) => (hash.to_string(), "id"),
+                };
+                if self.de.is_untyped {
+                    let accessor = match &expect.ty {
+                        Type::Null => "unit",
+                        Type::Record(_) => "struct",
+                        _ => "newtype",
+                    };
+                    label += &format!(",{},{},{}", label_type, accessor, expect_index);
                 }
-                // Okay to unwrap, as index_ty always has a value here.
-                self.de.table.current_type.push_front(index_ty.unwrap());
-                let val = seed.deserialize(&mut *self.de)?;
-                Ok((val, self))
+                self.de.set_field_name(Label::Named(label));
+                let field = seed.deserialize(&mut *self.de)?;
+                Ok((field, self))
             }
             _ => Err(Error::msg("expect enum")),
         }
@@ -1056,7 +880,7 @@ impl<'de, 'a> de::VariantAccess<'de> for Compound<'a, 'de> {
     type Error = Error;
 
     fn unit_variant(self) -> Result<()> {
-        self.de.table.check_type(Opcode::Null)?;
+        assert!(self.de.expect_type == Type::Null && self.de.wire_type == Type::Null);
         Ok(())
     }
 
@@ -1067,203 +891,17 @@ impl<'de, 'a> de::VariantAccess<'de> for Compound<'a, 'de> {
         seed.deserialize(self.de)
     }
 
-    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
+    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        de::Deserializer::deserialize_seq(self.de, visitor)
+        de::Deserializer::deserialize_tuple(self.de, len, visitor)
     }
 
     fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        if fields.is_empty() {
-            de::Deserializer::deserialize_any(self.de, visitor)
-        } else {
-            de::Deserializer::deserialize_struct(self.de, "_", fields, visitor)
-        }
-    }
-}
-
-/// Allow decoding of any sized argument.
-pub trait ArgumentDecoder<'a>: Sized {
-    /// Decodes a value of type [Self], modifying the deserializer (values are consumed).
-    fn decode(de: &mut IDLDeserialize<'a>) -> Result<Self>;
-}
-
-/// Decode an empty tuple.
-impl<'a> ArgumentDecoder<'a> for () {
-    fn decode(_de: &mut IDLDeserialize<'a>) -> Result<()> {
-        Ok(())
+        de::Deserializer::deserialize_struct(self.de, "_", fields, visitor)
     }
 }
-
-// Create implementation of [ArgumentDecoder] for up to 16 value tuples.
-macro_rules! decode_impl {
-    ( $($id: ident : $typename: ident),* ) => {
-        impl<'a, $( $typename ),*> ArgumentDecoder<'a> for ($($typename,)*)
-        where
-            $( $typename: Deserialize<'a> ),*
-        {
-            fn decode(de: &mut IDLDeserialize<'a>) -> Result<Self> {
-                $(
-                let $id: $typename = de.get_value()?;
-                )*
-
-                Ok(($( $id, )*))
-            }
-        }
-    }
-}
-
-decode_impl!(a: A);
-decode_impl!(a: A, b: B);
-decode_impl!(a: A, b: B, c: C);
-decode_impl!(a: A, b: B, c: C, d: D);
-decode_impl!(a: A, b: B, c: C, d: D, e: E);
-decode_impl!(a: A, b: B, c: C, d: D, e: E, f: F);
-decode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G);
-decode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H);
-decode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I);
-decode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J);
-decode_impl!(
-    a: A,
-    b: B,
-    c: C,
-    d: D,
-    e: E,
-    f: F,
-    g: G,
-    h: H,
-    i: I,
-    j: J,
-    k: K
-);
-decode_impl!(
-    a: A,
-    b: B,
-    c: C,
-    d: D,
-    e: E,
-    f: F,
-    g: G,
-    h: H,
-    i: I,
-    j: J,
-    k: K,
-    l: L
-);
-decode_impl!(
-    a: A,
-    b: B,
-    c: C,
-    d: D,
-    e: E,
-    f: F,
-    g: G,
-    h: H,
-    i: I,
-    j: J,
-    k: K,
-    l: L,
-    m: M
-);
-decode_impl!(
-    a: A,
-    b: B,
-    c: C,
-    d: D,
-    e: E,
-    f: F,
-    g: G,
-    h: H,
-    i: I,
-    j: J,
-    k: K,
-    l: L,
-    m: M,
-    n: N
-);
-decode_impl!(
-    a: A,
-    b: B,
-    c: C,
-    d: D,
-    e: E,
-    f: F,
-    g: G,
-    h: H,
-    i: I,
-    j: J,
-    k: K,
-    l: L,
-    m: M,
-    n: N,
-    o: O
-);
-decode_impl!(
-    a: A,
-    b: B,
-    c: C,
-    d: D,
-    e: E,
-    f: F,
-    g: G,
-    h: H,
-    i: I,
-    j: J,
-    k: K,
-    l: L,
-    m: M,
-    n: N,
-    o: O,
-    p: P
-);
-
-/// Decode a series of arguments, represented as a tuple. There is a maximum of 16 arguments
-/// supported.
-///
-/// Example:
-///
-/// ```
-/// # use candid::Encode;
-/// # use candid::de::decode_args;
-/// let golden1 = 123u64;
-/// let golden2 = "456";
-/// let bytes = Encode!(&golden1, &golden2).unwrap();
-/// let (value1, value2): (u64, String) = decode_args(&bytes).unwrap();
-///
-/// assert_eq!(golden1, value1);
-/// assert_eq!(golden2, value2);
-/// ```
-pub fn decode_args<'a, Tuple>(bytes: &'a [u8]) -> Result<Tuple>
-where
-    Tuple: ArgumentDecoder<'a>,
-{
-    let mut de = IDLDeserialize::new(bytes)?;
-    let res = ArgumentDecoder::decode(&mut de)?;
-    de.done()?;
-    Ok(res)
-}
-
-/// Decode a single argument.
-///
-/// Example:
-///
-/// ```
-/// # use candid::Encode;
-/// # use candid::de::decode_one;
-/// let golden1 = 123u64;
-/// let bytes = Encode!(&golden1).unwrap();
-/// let value1: u64 = decode_one(&bytes).unwrap();
-///
-/// assert_eq!(golden1, value1);
-/// ```
-pub fn decode_one<'a, T>(bytes: &'a [u8]) -> Result<T>
-where
-    T: Deserialize<'a>,
-{
-    let (res,) = decode_args(bytes)?;
-    Ok(res)
-}
diff --git a/rust/candid/src/error.rs b/rust/candid/src/error.rs
index b1c868a0..8df723fd 100644
--- a/rust/candid/src/error.rs
+++ b/rust/candid/src/error.rs
@@ -11,24 +11,21 @@ use thiserror::Error;
 
 pub type Result<T = ()> = std::result::Result<T, Error>;
 
-#[derive(Debug, Error, Eq, PartialEq)]
+#[derive(Debug, Error)]
 pub enum Error {
-    #[error("Candid parser error: {0:}")]
+    #[error("Candid parser error: {0}")]
     Parse(#[from] token::ParserError),
 
-    #[error("Deserialize error: {0}")]
-    Deserialize(String, String),
+    #[error("binary parser error: {}", .0.get(0).map(|f| format!("{} at byte offset {}", f.message, f.range.start/2)).unwrap_or_else(|| "io error".to_string()))]
+    Binread(Vec<Label<()>>),
 
-    #[error("{0}")]
-    Custom(String),
+    #[error(transparent)]
+    Custom(#[from] anyhow::Error),
 }
 
 impl Error {
     pub fn msg<T: ToString>(msg: T) -> Self {
-        Error::Custom(msg.to_string())
-    }
-    pub fn with_states(&self, states: String) -> Self {
-        Error::Deserialize(self.to_string(), states)
+        Error::Custom(anyhow::anyhow!(msg.to_string()))
     }
     pub fn report(&self) -> Diagnostic<()> {
         match self {
@@ -56,9 +53,57 @@ impl Error {
                 };
                 diag.with_labels(vec![label])
             }
-            Error::Deserialize(e, _) => Diagnostic::error().with_message(e),
-            Error::Custom(e) => Diagnostic::error().with_message(e),
+            Error::Binread(labels) => {
+                let diag = Diagnostic::error().with_message("decoding error");
+                diag.with_labels(labels.to_vec())
+            }
+            Error::Custom(e) => Diagnostic::error().with_message(e.to_string()),
+        }
+    }
+}
+
+fn get_binread_labels(e: &binread::Error) -> Vec<Label<()>> {
+    use binread::Error::*;
+    match e {
+        BadMagic { pos, .. } => {
+            let pos = (pos * 2) as usize;
+            vec![Label::primary((), pos..pos + 2).with_message("Unexpected bytes")]
+        }
+        Custom { pos, err } => {
+            let pos = (pos * 2) as usize;
+            let err = err
+                .downcast_ref::<&str>()
+                .unwrap_or(&"unknown error (there's a bug in error reporting)");
+            vec![Label::primary((), pos..pos + 2).with_message(err.to_string())]
+        }
+        EnumErrors {
+            pos,
+            variant_errors,
+        } => {
+            let pos = (pos * 2) as usize;
+            let variant = variant_errors
+                .iter()
+                .find(|(_, e)| !matches!(e, BadMagic { .. }));
+            // Should have at most one non-magic error
+            match variant {
+                None => vec![Label::primary((), pos..pos + 2).with_message("Unknown opcode")],
+                Some((id, e)) => {
+                    let mut labels = get_binread_labels(e);
+                    labels.push(Label::secondary((), pos..pos + 2).with_message(id.to_string()));
+                    labels
+                }
+            }
         }
+        NoVariantMatch { pos } => {
+            let pos = (pos * 2) as usize;
+            vec![Label::primary((), pos..pos + 2).with_message("No variant match")]
+        }
+        AssertFail { pos, message } => {
+            let pos = (pos * 2) as usize;
+            vec![Label::primary((), pos..pos + 2).with_message(message)]
+        }
+        Io(_) => vec![],
+        _ => unreachable!(),
     }
 }
 
@@ -98,6 +143,12 @@ impl From<io::Error> for Error {
     }
 }
 
+impl From<binread::Error> for Error {
+    fn from(e: binread::Error) -> Error {
+        Error::Binread(get_binread_labels(&e))
+    }
+}
+
 #[cfg(feature = "random")]
 impl From<arbitrary::Error> for Error {
     fn from(e: arbitrary::Error) -> Error {
@@ -124,3 +175,18 @@ where
         Err(e)
     })
 }
+
+pub fn pretty_read<T>(reader: &mut std::io::Cursor<&[u8]>) -> Result<T>
+where
+    T: binread::BinRead,
+{
+    T::read(reader).or_else(|e| {
+        let e = Error::from(e);
+        let writer = StandardStream::stderr(term::termcolor::ColorChoice::Auto);
+        let config = term::Config::default();
+        let str = hex::encode(&reader.get_ref());
+        let file = SimpleFile::new("binary", &str);
+        term::emit(&mut writer.lock(), &config, &file, &e.report())?;
+        Err(e)
+    })
+}
diff --git a/rust/candid/src/lib.rs b/rust/candid/src/lib.rs
index 99c2fb63..1c4f76bc 100644
--- a/rust/candid/src/lib.rs
+++ b/rust/candid/src/lib.rs
@@ -257,7 +257,7 @@ pub use codegen::generate_code;
 pub mod bindings;
 
 pub mod error;
-pub use error::{pretty_parse, Error, Result};
+pub use error::{pretty_parse, pretty_read, Error, Result};
 
 pub mod types;
 pub use types::CandidType;
@@ -273,11 +273,12 @@ pub use parser::types::IDLProg;
 pub use parser::typing::{check_prog, TypeEnv};
 pub use parser::value::IDLArgs;
 
+pub mod binary_parser;
 pub mod de;
-pub use de::{decode_args, decode_one};
 pub mod ser;
-pub use ser::{encode_args, encode_one};
 
+pub mod utils;
+pub use utils::{decode_args, decode_one, encode_args, encode_one, write_args};
 pub mod pretty;
 
 // Candid hash function comes from
@@ -293,37 +294,3 @@ pub fn idl_hash(id: &str) -> u32 {
     }
     s
 }
-
-/// Encode sequence of Rust values into Candid message of type `candid::Result<Vec<u8>>`.
-#[macro_export]
-macro_rules! Encode {
-    ( $($x:expr),* ) => {{
-        let mut builder = $crate::ser::IDLBuilder::new();
-        Encode!(@PutValue builder $($x,)*)
-    }};
-    ( @PutValue $builder:ident $x:expr, $($tail:expr,)* ) => {{
-        $builder.arg($x).and_then(|builder| Encode!(@PutValue builder $($tail,)*))
-    }};
-    ( @PutValue $builder:ident ) => {{
-        $builder.serialize_to_vec()
-    }};
-}
-
-/// Decode Candid message into a tuple of Rust values of the given types.
-/// Produces `Err` if the message fails to decode at any given types.
-/// If the message contains only one value, it returns the value directly instead of a tuple.
-#[macro_export]
-macro_rules! Decode {
-    ( $hex:expr $(,$ty:ty)* ) => {{
-        $crate::de::IDLDeserialize::new($hex)
-            .and_then(|mut de| Decode!(@GetValue [] de $($ty,)*)
-                      .and_then(|res| de.done().and(Ok(res))))
-    }};
-    (@GetValue [$($ans:ident)*] $de:ident $ty:ty, $($tail:ty,)* ) => {{
-        $de.get_value::<$ty>()
-            .and_then(|val| Decode!(@GetValue [$($ans)* val] $de $($tail,)* ))
-    }};
-    (@GetValue [$($ans:ident)*] $de:ident) => {{
-        Ok(($($ans),*))
-    }};
-}
diff --git a/rust/candid/src/parser/test.rs b/rust/candid/src/parser/test.rs
index a03fa605..5b7c461a 100644
--- a/rust/candid/src/parser/test.rs
+++ b/rust/candid/src/parser/test.rs
@@ -157,6 +157,9 @@ pub fn check(test: Test) -> Result<()> {
                 print!("[round-trip failed] ");
             }
             let is_equal = left == right;
+            if assert.pass != is_equal {
+                print!(" left:{}, right:{} ", left, right);
+            }
             assert.pass == is_equal
         } else {
             let res = assert.pass == input.is_ok();
diff --git a/rust/candid/src/parser/typing.rs b/rust/candid/src/parser/typing.rs
index 82165ba6..583c0a10 100644
--- a/rust/candid/src/parser/typing.rs
+++ b/rust/candid/src/parser/typing.rs
@@ -74,8 +74,61 @@ impl TypeEnv {
         }
         Err(Error::msg(format!("cannot find method {}", id)))
     }
+    fn go<'a>(
+        &'a self,
+        seen: &mut BTreeSet<&'a str>,
+        res: &mut BTreeSet<&'a str>,
+        t: &'a Type,
+    ) -> Result<()> {
+        if !res.is_empty() {
+            return Ok(());
+        }
+        match &t {
+            Type::Record(fs) => {
+                for f in fs.iter() {
+                    self.go(seen, res, &f.ty)?;
+                }
+            }
+            Type::Var(id) => {
+                if seen.insert(id) {
+                    let t = self.find_type(id)?;
+                    self.go(seen, res, t)?;
+                    seen.remove(&id.as_str());
+                } else {
+                    *res = seen.clone();
+                }
+            }
+            _ => (),
+        }
+        Ok(())
+    }
+    fn check_empty(&self) -> Result<BTreeSet<&str>> {
+        let mut res = BTreeSet::new();
+        for (name, t) in self.0.iter() {
+            let mut seen: BTreeSet<&str> = BTreeSet::new();
+            let mut local_res = BTreeSet::new();
+            seen.insert(name);
+            self.go(&mut seen, &mut local_res, t)?;
+            res.append(&mut local_res);
+        }
+        Ok(res)
+    }
+    pub fn replace_empty(&mut self) -> Result<()> {
+        let ids: Vec<_> = self.check_empty()?.iter().map(|x| x.to_string()).collect();
+        for id in ids.into_iter() {
+            self.0.insert(id, Type::Empty);
+        }
+        Ok(())
+    }
+}
+impl std::fmt::Display for TypeEnv {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for (k, v) in self.0.iter() {
+            writeln!(f, "type {} = {}", k, v)?;
+        }
+        Ok(())
+    }
 }
-
 fn check_prim(prim: &PrimType) -> Type {
     match prim {
         PrimType::Nat => Type::Nat,
diff --git a/rust/candid/src/parser/value.rs b/rust/candid/src/parser/value.rs
index c66b80bf..e669b333 100644
--- a/rust/candid/src/parser/value.rs
+++ b/rust/candid/src/parser/value.rs
@@ -57,14 +57,25 @@ impl IDLArgs {
         }
     }
     pub fn annotate_types(self, from_parser: bool, env: &TypeEnv, types: &[Type]) -> Result<Self> {
-        if types.len() > self.args.len() {
-            return Err(Error::msg("wrong number of argument values"));
-        }
         let mut args = Vec::new();
         for (v, ty) in self.args.iter().zip(types.iter()) {
             let v = v.annotate_type(from_parser, env, &ty)?;
             args.push(v);
         }
+        for ty in types[self.args.len()..].iter() {
+            let v = match env.trace_type(ty)? {
+                Type::Null => IDLValue::Null,
+                Type::Reserved => IDLValue::Reserved,
+                Type::Opt(_) => IDLValue::None,
+                _ => {
+                    return Err(Error::msg(format!(
+                        "Omitted values cannot be of type {}",
+                        ty
+                    )))
+                }
+            };
+            args.push(v);
+        }
         Ok(IDLArgs { args })
     }
     /// Encode IDLArgs with the given types. Note that this is not equivalent to
@@ -96,8 +107,7 @@ impl IDLArgs {
         let mut de = crate::de::IDLDeserialize::new(bytes)?;
         let mut args = Vec::new();
         for ty in types.iter() {
-            let v = de.get_value::<IDLValue>()?;
-            let v = v.annotate_type(false, env, ty)?;
+            let v = de.get_value_with_type(env, ty)?;
             args.push(v);
         }
         de.done()?;
@@ -132,8 +142,9 @@ impl std::str::FromStr for IDLValue {
 }
 
 impl IDLValue {
-    /// Anotate `IDLValue` with the given type, allowing subtyping. If `IDLValue` is parser from
-    /// string, we need to set `from_parser` to true to enable converting numbers to the expected types.
+    /// Anotate `IDLValue` with the given type, allowing subtyping. If `IDLValue` is parsed from
+    /// string, we need to set `from_parser` to true to enable converting numbers to the expected
+    /// types, and disable the opt rules.
     pub fn annotate_type(&self, from_parser: bool, env: &TypeEnv, t: &Type) -> Result<Self> {
         Ok(match (self, t) {
             (_, Type::Var(id)) => {
@@ -146,24 +157,6 @@ impl IDLValue {
             }
             (_, Type::Reserved) => IDLValue::Reserved,
             (IDLValue::Float64(n), Type::Float32) if from_parser => IDLValue::Float32(*n as f32),
-            (IDLValue::Number(str), t) if from_parser => match t {
-                Type::Int => IDLValue::Int(str.parse::<Int>()?),
-                Type::Nat => IDLValue::Nat(str.parse::<Nat>()?),
-                Type::Nat8 => IDLValue::Nat8(str.parse::<u8>().map_err(error)?),
-                Type::Nat16 => IDLValue::Nat16(str.parse::<u16>().map_err(error)?),
-                Type::Nat32 => IDLValue::Nat32(str.parse::<u32>().map_err(error)?),
-                Type::Nat64 => IDLValue::Nat64(str.parse::<u64>().map_err(error)?),
-                Type::Int8 => IDLValue::Int8(str.parse::<i8>().map_err(error)?),
-                Type::Int16 => IDLValue::Int16(str.parse::<i16>().map_err(error)?),
-                Type::Int32 => IDLValue::Int32(str.parse::<i32>().map_err(error)?),
-                Type::Int64 => IDLValue::Int64(str.parse::<i64>().map_err(error)?),
-                _ => {
-                    return Err(Error::msg(format!(
-                        "type mismatch: {} can not be of type {}",
-                        self, t
-                    )))
-                }
-            },
             (IDLValue::Null, Type::Null) => IDLValue::Null,
             (IDLValue::Bool(b), Type::Bool) => IDLValue::Bool(*b),
             (IDLValue::Nat(n), Type::Nat) => IDLValue::Nat(n.clone()),
@@ -184,24 +177,28 @@ impl IDLValue {
             (IDLValue::Null, Type::Opt(_)) => IDLValue::None,
             (IDLValue::Reserved, Type::Opt(_)) => IDLValue::None,
             (IDLValue::None, Type::Opt(_)) => IDLValue::None,
+            (IDLValue::Opt(v), Type::Opt(ty)) if from_parser => {
+                IDLValue::Opt(Box::new(v.annotate_type(from_parser, env, ty)?))
+            }
             // liberal decoding of optionals
-            (IDLValue::Opt(v), Type::Opt(ty)) => v
+            (IDLValue::Opt(v), Type::Opt(ty)) if !from_parser => v
                 .annotate_type(from_parser, env, ty)
                 .map(|v| IDLValue::Opt(Box::new(v)))
                 .unwrap_or(IDLValue::None),
             // try consituent type
             (v, Type::Opt(ty))
-                if !matches!(
-                    env.trace_type(ty)?,
-                    Type::Null | Type::Reserved | Type::Opt(_)
-                ) =>
+                if !from_parser
+                    && !matches!(
+                        env.trace_type(ty)?,
+                        Type::Null | Type::Reserved | Type::Opt(_)
+                    ) =>
             {
                 v.annotate_type(from_parser, env, ty)
                     .map(|v| IDLValue::Opt(Box::new(v)))
                     .unwrap_or(IDLValue::None)
             }
             // fallback
-            (_, Type::Opt(_)) => IDLValue::None,
+            (_, Type::Opt(_)) if !from_parser => IDLValue::None,
             (IDLValue::Vec(vec), Type::Vec(ty)) => {
                 let mut res = Vec::new();
                 for e in vec.iter() {
@@ -223,7 +220,7 @@ impl IDLValue {
                             Type::Reserved => Some(&IDLValue::Reserved),
                             _ => None,
                         })
-                        .ok_or_else(|| Error::msg(format!("required field {} not found", id)))?;
+                        .ok_or_else(|| Error::msg(format!("record field {} not found", id)))?;
                     let val = val.annotate_type(from_parser, env, ty)?;
                     res.push(IDLField {
                         id: id.clone(),
@@ -243,11 +240,29 @@ impl IDLValue {
                         return Ok(IDLValue::Variant(Box::new(field), i as u64));
                     }
                 }
-                return Err(Error::msg(format!("field {} not found", v.id)));
+                return Err(Error::msg(format!("variant field {} not found", v.id)));
             }
             (IDLValue::Principal(id), Type::Principal) => IDLValue::Principal(id.clone()),
             (IDLValue::Service(_), Type::Service(_)) => self.clone(),
             (IDLValue::Func(_, _), Type::Func(_)) => self.clone(),
+            (IDLValue::Number(str), t) if from_parser => match t {
+                Type::Int => IDLValue::Int(str.parse::<Int>()?),
+                Type::Nat => IDLValue::Nat(str.parse::<Nat>()?),
+                Type::Nat8 => IDLValue::Nat8(str.parse::<u8>().map_err(error)?),
+                Type::Nat16 => IDLValue::Nat16(str.parse::<u16>().map_err(error)?),
+                Type::Nat32 => IDLValue::Nat32(str.parse::<u32>().map_err(error)?),
+                Type::Nat64 => IDLValue::Nat64(str.parse::<u64>().map_err(error)?),
+                Type::Int8 => IDLValue::Int8(str.parse::<i8>().map_err(error)?),
+                Type::Int16 => IDLValue::Int16(str.parse::<i16>().map_err(error)?),
+                Type::Int32 => IDLValue::Int32(str.parse::<i32>().map_err(error)?),
+                Type::Int64 => IDLValue::Int64(str.parse::<i64>().map_err(error)?),
+                _ => {
+                    return Err(Error::msg(format!(
+                        "type mismatch: {} can not be of type {}",
+                        self, t
+                    )))
+                }
+            },
             _ => {
                 return Err(Error::msg(format!(
                     "type mismatch: {} cannot be of type {}",
@@ -323,13 +338,13 @@ impl IDLValue {
 
 impl crate::CandidType for IDLValue {
     fn ty() -> Type {
-        unreachable!()
+        Type::Unknown
     }
     fn id() -> crate::types::TypeId {
         unreachable!();
     }
     fn _ty() -> Type {
-        unreachable!()
+        Type::Unknown
     }
     fn idl_serialize<S>(&self, serializer: S) -> std::result::Result<(), S::Error>
     where
@@ -493,15 +508,14 @@ impl<'de> Deserialize<'de> for IDLValue {
             {
                 let mut vec = Vec::new();
                 while let Some((key, value)) = visitor.next_entry()? {
-                    if let IDLValue::Nat32(hash) = key {
-                        let f = IDLField {
-                            id: Label::Id(hash),
-                            val: value,
-                        };
-                        vec.push(f);
-                    } else {
-                        unreachable!()
-                    }
+                    let id = match key {
+                        IDLValue::Nat32(hash) => Label::Id(hash),
+                        IDLValue::Text(name) if name == "_" => continue,
+                        IDLValue::Text(name) => Label::Named(name),
+                        _ => unreachable!(),
+                    };
+                    let f = IDLField { id, val: value };
+                    vec.push(f);
                 }
                 Ok(IDLValue::Record(vec))
             }
@@ -513,9 +527,20 @@ impl<'de> Deserialize<'de> for IDLValue {
                 let (variant, visitor) = data.variant::<IDLValue>()?;
                 if let IDLValue::Text(v) = variant {
                     let v: Vec<_> = v.split(',').collect();
-                    assert_eq!(v.len(), 2);
-                    let id = v[0].parse::<u32>().unwrap();
-                    let val = match v[1] {
+                    let (id, style, ind) = match v.as_slice() {
+                        [name, "name", style, ind] => (
+                            Label::Named(name.to_string()),
+                            style,
+                            ind.parse::<u64>().unwrap(),
+                        ),
+                        [hash, "id", style, ind] => (
+                            Label::Id(hash.parse::<u32>().unwrap()),
+                            style,
+                            ind.parse::<u64>().unwrap(),
+                        ),
+                        _ => unreachable!(),
+                    };
+                    let val = match *style {
                         "unit" => {
                             visitor.unit_variant()?;
                             IDLValue::Null
@@ -524,13 +549,10 @@ impl<'de> Deserialize<'de> for IDLValue {
                         "newtype" => visitor.newtype_variant()?,
                         _ => unreachable!(),
                     };
-                    let f = IDLField {
-                        id: Label::Id(id),
-                        val,
-                    };
+                    let f = IDLField { id, val };
                     // Deserialized variant always has 0 index to ensure untyped
                     // serialization is correct.
-                    Ok(IDLValue::Variant(Box::new(f), 0))
+                    Ok(IDLValue::Variant(Box::new(f), ind))
                 } else {
                     unreachable!()
                 }
diff --git a/rust/candid/src/ser.rs b/rust/candid/src/ser.rs
index f5bbce82..d67dded6 100644
--- a/rust/candid/src/ser.rs
+++ b/rust/candid/src/ser.rs
@@ -407,196 +407,3 @@ impl TypeSerialize {
         Ok(())
     }
 }
-
-/// Allow encoding of any serializable value.
-pub trait ArgumentEncoder {
-    /// Encode a value of type [Self].
-    fn encode(self, ser: &mut IDLBuilder) -> Result<()>;
-}
-
-/// Decode an empty tuple.
-impl ArgumentEncoder for () {
-    fn encode(self, _de: &mut IDLBuilder) -> Result<()> {
-        Ok(())
-    }
-}
-
-// Create implementation of [ArgumentEncoder] for up to 16 value tuples.
-macro_rules! encode_impl {
-    ( $($id: ident : $typename: ident),* ) => {
-        impl<$( $typename ),*> ArgumentEncoder for ($($typename,)*)
-        where
-            $( $typename: types::CandidType ),*
-        {
-            fn encode(self, ser: &mut IDLBuilder) -> Result<()> {
-                let ( $( $id, )* ) = self;
-                $(
-                ser.arg(&$id)?;
-                )*
-
-                Ok(())
-            }
-        }
-    }
-}
-
-encode_impl!(a: A);
-encode_impl!(a: A, b: B);
-encode_impl!(a: A, b: B, c: C);
-encode_impl!(a: A, b: B, c: C, d: D);
-encode_impl!(a: A, b: B, c: C, d: D, e: E);
-encode_impl!(a: A, b: B, c: C, d: D, e: E, f: F);
-encode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G);
-encode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H);
-encode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I);
-encode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J);
-encode_impl!(
-    a: A,
-    b: B,
-    c: C,
-    d: D,
-    e: E,
-    f: F,
-    g: G,
-    h: H,
-    i: I,
-    j: J,
-    k: K
-);
-encode_impl!(
-    a: A,
-    b: B,
-    c: C,
-    d: D,
-    e: E,
-    f: F,
-    g: G,
-    h: H,
-    i: I,
-    j: J,
-    k: K,
-    l: L
-);
-encode_impl!(
-    a: A,
-    b: B,
-    c: C,
-    d: D,
-    e: E,
-    f: F,
-    g: G,
-    h: H,
-    i: I,
-    j: J,
-    k: K,
-    l: L,
-    m: M
-);
-encode_impl!(
-    a: A,
-    b: B,
-    c: C,
-    d: D,
-    e: E,
-    f: F,
-    g: G,
-    h: H,
-    i: I,
-    j: J,
-    k: K,
-    l: L,
-    m: M,
-    n: N
-);
-encode_impl!(
-    a: A,
-    b: B,
-    c: C,
-    d: D,
-    e: E,
-    f: F,
-    g: G,
-    h: H,
-    i: I,
-    j: J,
-    k: K,
-    l: L,
-    m: M,
-    n: N,
-    o: O
-);
-encode_impl!(
-    a: A,
-    b: B,
-    c: C,
-    d: D,
-    e: E,
-    f: F,
-    g: G,
-    h: H,
-    i: I,
-    j: J,
-    k: K,
-    l: L,
-    m: M,
-    n: N,
-    o: O,
-    p: P
-);
-
-/// Serialize an encoding of a tuple and write it to a [Write] buffer.
-///
-/// ```
-/// # use candid::Decode;
-/// # use candid::ser::write_args;
-/// let golden1 = 1u64;
-/// let golden2 = "hello";
-/// let mut buffer = Vec::new();
-/// write_args(&mut buffer, (golden1, golden2)).unwrap();
-///
-/// let (value1, value2) = Decode!(&buffer, u64, String).unwrap();
-/// assert_eq!(golden1, value1);
-/// assert_eq!(golden2, value2);
-/// ```
-pub fn write_args<Tuple: ArgumentEncoder, Writer: std::io::Write>(
-    writer: &mut Writer,
-    arguments: Tuple,
-) -> Result<()> {
-    let mut ser = IDLBuilder::new();
-    arguments.encode(&mut ser)?;
-    ser.serialize(writer)
-}
-
-/// Serialize an encoding of a tuple to a vector of bytes.
-///
-/// ```
-/// # use candid::Decode;
-/// # use candid::ser::encode_args;
-/// let golden1 = 1u64;
-/// let golden2 = "hello";
-/// let buffer = encode_args((golden1, golden2)).unwrap();
-///
-/// let (value1, value2) = Decode!(&buffer, u64, String).unwrap();
-/// assert_eq!(golden1, value1);
-/// assert_eq!(golden2, value2);
-/// ```
-pub fn encode_args<Tuple: ArgumentEncoder>(arguments: Tuple) -> Result<Vec<u8>> {
-    let mut result = Vec::new();
-    write_args(&mut result, arguments)?;
-    Ok(result)
-}
-
-/// Serialize a single value to a vector of bytes.
-///
-/// ```
-/// # use candid::Decode;
-/// # use candid::ser::encode_one;
-/// let golden = "hello";
-/// let buffer = encode_one(golden).unwrap();
-///
-/// let (value) = Decode!(&buffer, String).unwrap();
-/// assert_eq!(golden, value);
-/// ```
-pub fn encode_one<T: types::CandidType>(argument: T) -> Result<Vec<u8>> {
-    encode_args((argument,))
-}
diff --git a/rust/candid/src/types/subtype.rs b/rust/candid/src/types/subtype.rs
index 0543ddeb..fe1a5ab0 100644
--- a/rust/candid/src/types/subtype.rs
+++ b/rust/candid/src/types/subtype.rs
@@ -1,18 +1,26 @@
 use super::internal::{find_type, Field, Label, Type};
 use crate::parser::typing::TypeEnv;
+use crate::{Error, Result};
+use anyhow::Context;
 use std::collections::{HashMap, HashSet};
 
 pub type Gamma = HashSet<(Type, Type)>;
 
 /// Check if t1 <: t2
-pub fn subtype(gamma: &mut Gamma, env1: &TypeEnv, t1: &Type, env2: &TypeEnv, t2: &Type) -> bool {
+pub fn subtype(
+    gamma: &mut Gamma,
+    env1: &TypeEnv,
+    t1: &Type,
+    env2: &TypeEnv,
+    t2: &Type,
+) -> Result<()> {
     use Type::*;
     if t1 == t2 {
-        return true;
+        return Ok(());
     }
     if matches!(t1, Var(_) | Knot(_)) || matches!(t2, Var(_) | Knot(_)) {
         if !gamma.insert((t1.clone(), t2.clone())) {
-            return true;
+            return Ok(());
         }
         let res = match (t1, t2) {
             (Var(id), _) => subtype(gamma, env1, env1.rec_find_type(id).unwrap(), env2, t2),
@@ -21,67 +29,92 @@ pub fn subtype(gamma: &mut Gamma, env1: &TypeEnv, t1: &Type, env2: &TypeEnv, t2:
             (_, Knot(id)) => subtype(gamma, env1, t1, env2, &find_type(id).unwrap()),
             (_, _) => unreachable!(),
         };
-        if !res {
+        if res.is_err() {
             gamma.remove(&(t1.clone(), t2.clone()));
         }
         return res;
     }
     match (t1, t2) {
-        (_, Reserved) => true,
-        (Empty, _) => true,
-        (Nat, Int) => true,
+        (_, Reserved) => Ok(()),
+        (Empty, _) => Ok(()),
+        (Nat, Int) => Ok(()),
         (Vec(ty1), Vec(ty2)) => subtype(gamma, env1, ty1, env2, ty2),
-        (Null, Opt(_)) => true,
-        (Opt(ty1), Opt(ty2)) if subtype(gamma, env1, ty1, env2, ty2) => true,
+        (Null, Opt(_)) => Ok(()),
+        (Opt(ty1), Opt(ty2)) if subtype(gamma, env1, ty1, env2, ty2).is_ok() => Ok(()),
         (t1, Opt(ty2))
-            if subtype(gamma, env1, t1, env2, ty2)
-                && !matches!(env2.trace_type(ty2).unwrap(), Null | Reserved | Opt(_)) =>
+            if subtype(gamma, env1, t1, env2, ty2).is_ok()
+                && !matches!(env2.trace_type(ty2)?, Null | Reserved | Opt(_)) =>
         {
-            true
+            Ok(())
         }
         (t1, Opt(_)) => {
             eprintln!("{} <: {} via special opt rule", t1, t2);
-            true
+            Ok(())
         }
         (Record(fs1), Record(fs2)) => {
             let fields: HashMap<_, _> = fs1.iter().map(|Field { id, ty }| (id, ty)).collect();
-            fs2.iter()
-                .all(|Field { id, ty: ty2 }| match fields.get(id) {
-                    Some(ty1) => subtype(gamma, env1, ty1, env2, ty2),
-                    None => subtype(gamma, env1, &Opt(Box::new(Empty)), env2, ty2),
-                })
+            for Field { id, ty: ty2 } in fs2.iter() {
+                match fields.get(id) {
+                    Some(ty1) => subtype(gamma, env1, ty1, env2, ty2).with_context(|| format!("Record field {}: {} is not a subtype of {}", id, ty1, ty2))?,
+                    None => subtype(gamma, env1, &Opt(Box::new(Empty)), env2, ty2).map_err(|_| anyhow::anyhow!("Record field {}: {} is only in the expected type and is not of opt, reserved or null type", id, ty2))?,
+                }
+            }
+            Ok(())
         }
         (Variant(fs1), Variant(fs2)) => {
             let fields: HashMap<_, _> = fs2.iter().map(|Field { id, ty }| (id, ty)).collect();
-            fs1.iter()
-                .all(|Field { id, ty: ty1 }| match fields.get(id) {
-                    Some(ty2) => subtype(gamma, env1, ty1, env2, ty2),
-                    None => false,
-                })
+            for Field { id, ty: ty1 } in fs1.iter() {
+                match fields.get(id) {
+                    Some(ty2) => subtype(gamma, env1, ty1, env2, ty2).with_context(|| {
+                        format!("Variant field {}: {} is not a subtype of {}", id, ty1, ty2)
+                    })?,
+                    None => {
+                        return Err(Error::msg(format!(
+                            "Variant field {} not found in the expected type",
+                            id
+                        )))
+                    }
+                }
+            }
+            Ok(())
         }
         (Service(ms1), Service(ms2)) => {
-            let meths: HashMap<_, _> = ms2.iter().map(|(name, ty)| (name, ty)).collect();
-            ms1.iter().all(|(name, ty1)| match meths.get(name) {
-                Some(ty2) => subtype(gamma, env1, ty1, env2, ty2),
-                None => false,
-            })
+            let meths: HashMap<_, _> = ms1.iter().map(|(name, ty)| (name, ty)).collect();
+            for (name, ty2) in ms2.iter() {
+                match meths.get(name) {
+                    Some(ty1) => subtype(gamma, env1, ty1, env2, ty2).with_context(|| {
+                        format!("Method {}: {} is not a subtype of {}", name, ty1, ty2)
+                    })?,
+                    None => {
+                        return Err(Error::msg(format!(
+                            "Method {} is only in the expected type",
+                            name
+                        )))
+                    }
+                }
+            }
+            Ok(())
         }
         (Func(f1), Func(f2)) => {
             let m1: HashSet<_> = f1.modes.iter().collect();
             let m2: HashSet<_> = f2.modes.iter().collect();
             if m1 != m2 {
-                return false;
+                return Err(Error::msg("Function mode mismatch"));
             }
             let args1 = to_tuple(&f1.args);
             let args2 = to_tuple(&f2.args);
             let rets1 = to_tuple(&f1.rets);
             let rets2 = to_tuple(&f2.rets);
-            subtype(gamma, env2, &args2, env1, &args1) && subtype(gamma, env1, &rets1, env2, &rets2)
+            subtype(gamma, env2, &args2, env1, &args1)
+                .context("Subtype fails at function input type")?;
+            subtype(gamma, env1, &rets1, env2, &rets2)
+                .context("Subtype fails at function return type")?;
+            Ok(())
         }
         (Class(_, _), Class(_, _)) => unreachable!(),
         (Unknown, _) => unreachable!(),
         (_, Unknown) => unreachable!(),
-        (_, _) => false,
+        (_, _) => Err(Error::msg(format!("{} is not a subtype of {}", t1, t2))),
     }
 }
 
diff --git a/rust/candid/src/utils.rs b/rust/candid/src/utils.rs
new file mode 100644
index 00000000..cf2bbd8d
--- /dev/null
+++ b/rust/candid/src/utils.rs
@@ -0,0 +1,251 @@
+use crate::de::IDLDeserialize;
+use crate::ser::IDLBuilder;
+use crate::{CandidType, Result};
+use serde::de::Deserialize;
+
+/// Encode sequence of Rust values into Candid message of type `candid::Result<Vec<u8>>`.
+#[macro_export]
+macro_rules! Encode {
+    ( $($x:expr),* ) => {{
+        let mut builder = $crate::ser::IDLBuilder::new();
+        Encode!(@PutValue builder $($x,)*)
+    }};
+    ( @PutValue $builder:ident $x:expr, $($tail:expr,)* ) => {{
+        $builder.arg($x).and_then(|builder| Encode!(@PutValue builder $($tail,)*))
+    }};
+    ( @PutValue $builder:ident ) => {{
+        $builder.serialize_to_vec()
+    }};
+}
+
+/// Decode Candid message into a tuple of Rust values of the given types.
+/// Produces `Err` if the message fails to decode at any given types.
+/// If the message contains only one value, it returns the value directly instead of a tuple.
+#[macro_export]
+macro_rules! Decode {
+    ( $hex:expr $(,$ty:ty)* ) => {{
+        $crate::de::IDLDeserialize::new($hex)
+            .and_then(|mut de| Decode!(@GetValue [] de $($ty,)*)
+                      .and_then(|res| de.done().and(Ok(res))))
+    }};
+    (@GetValue [$($ans:ident)*] $de:ident $ty:ty, $($tail:ty,)* ) => {{
+        $de.get_value::<$ty>()
+            .and_then(|val| Decode!(@GetValue [$($ans)* val] $de $($tail,)* ))
+    }};
+    (@GetValue [$($ans:ident)*] $de:ident) => {{
+        Ok(($($ans),*))
+    }};
+}
+
+/// Decode a series of arguments, represented as a tuple. There is a maximum of 16 arguments
+/// supported.
+///
+/// Example:
+///
+/// ```
+/// # use candid::Encode;
+/// # use candid::decode_args;
+/// let golden1 = 123u64;
+/// let golden2 = "456";
+/// let bytes = Encode!(&golden1, &golden2).unwrap();
+/// let (value1, value2): (u64, String) = decode_args(&bytes).unwrap();
+///
+/// assert_eq!(golden1, value1);
+/// assert_eq!(golden2, value2);
+/// ```
+pub fn decode_args<'a, Tuple>(bytes: &'a [u8]) -> Result<Tuple>
+where
+    Tuple: ArgumentDecoder<'a>,
+{
+    let mut de = IDLDeserialize::new(bytes)?;
+    let res = ArgumentDecoder::decode(&mut de)?;
+    de.done()?;
+    Ok(res)
+}
+
+/// Decode a single argument.
+///
+/// Example:
+///
+/// ```
+/// # use candid::Encode;
+/// # use candid::decode_one;
+/// let golden1 = 123u64;
+/// let bytes = Encode!(&golden1).unwrap();
+/// let value1: u64 = decode_one(&bytes).unwrap();
+///
+/// assert_eq!(golden1, value1);
+/// ```
+pub fn decode_one<'a, T>(bytes: &'a [u8]) -> Result<T>
+where
+    T: Deserialize<'a> + CandidType,
+{
+    let (res,) = decode_args(bytes)?;
+    Ok(res)
+}
+
+/// Serialize an encoding of a tuple and write it to a [Write] buffer.
+///
+/// ```
+/// # use candid::Decode;
+/// # use candid::write_args;
+/// let golden1 = 1u64;
+/// let golden2 = "hello";
+/// let mut buffer = Vec::new();
+/// write_args(&mut buffer, (golden1, golden2)).unwrap();
+///
+/// let (value1, value2) = Decode!(&buffer, u64, String).unwrap();
+/// assert_eq!(golden1, value1);
+/// assert_eq!(golden2, value2);
+/// ```
+pub fn write_args<Tuple: ArgumentEncoder, Writer: std::io::Write>(
+    writer: &mut Writer,
+    arguments: Tuple,
+) -> Result<()> {
+    let mut ser = IDLBuilder::new();
+    arguments.encode(&mut ser)?;
+    ser.serialize(writer)
+}
+
+/// Serialize an encoding of a tuple to a vector of bytes.
+///
+/// ```
+/// # use candid::Decode;
+/// # use candid::encode_args;
+/// let golden1 = 1u64;
+/// let golden2 = "hello";
+/// let buffer = encode_args((golden1, golden2)).unwrap();
+///
+/// let (value1, value2) = Decode!(&buffer, u64, String).unwrap();
+/// assert_eq!(golden1, value1);
+/// assert_eq!(golden2, value2);
+/// ```
+pub fn encode_args<Tuple: ArgumentEncoder>(arguments: Tuple) -> Result<Vec<u8>> {
+    let mut result = Vec::new();
+    write_args(&mut result, arguments)?;
+    Ok(result)
+}
+
+/// Serialize a single value to a vector of bytes.
+///
+/// ```
+/// # use candid::Decode;
+/// # use candid::encode_one;
+/// let golden = "hello";
+/// let buffer = encode_one(golden).unwrap();
+///
+/// let (value) = Decode!(&buffer, String).unwrap();
+/// assert_eq!(golden, value);
+/// ```
+pub fn encode_one<T: CandidType>(argument: T) -> Result<Vec<u8>> {
+    encode_args((argument,))
+}
+
+/// Allow decoding of any sized argument.
+pub trait ArgumentDecoder<'a>: Sized {
+    /// Decodes a value of type [Self], modifying the deserializer (values are consumed).
+    fn decode(de: &mut IDLDeserialize<'a>) -> Result<Self>;
+}
+
+/// Decode an empty tuple.
+impl<'a> ArgumentDecoder<'a> for () {
+    fn decode(_de: &mut IDLDeserialize<'a>) -> Result<()> {
+        Ok(())
+    }
+}
+
+/// Allow encoding of any serializable value.
+pub trait ArgumentEncoder {
+    /// Encode a value of type [Self].
+    fn encode(self, ser: &mut IDLBuilder) -> Result<()>;
+}
+
+/// Decode an empty tuple.
+impl ArgumentEncoder for () {
+    fn encode(self, _de: &mut IDLBuilder) -> Result<()> {
+        Ok(())
+    }
+}
+
+// Create implementation of [ArgumentDecoder] for up to 16 value tuples.
+macro_rules! decode_impl {
+    ( $($id: ident : $typename: ident),* ) => {
+        impl<'a, $( $typename ),*> ArgumentDecoder<'a> for ($($typename,)*)
+        where
+            $( $typename: Deserialize<'a> + CandidType ),*
+        {
+            fn decode(de: &mut IDLDeserialize<'a>) -> Result<Self> {
+                $(
+                let $id: $typename = de.get_value()?;
+                )*
+
+                Ok(($( $id, )*))
+            }
+        }
+    }
+}
+
+// Create implementation of [ArgumentEncoder] for up to 16 value tuples.
+macro_rules! encode_impl {
+    ( $($id: ident : $typename: ident),* ) => {
+        impl<$( $typename ),*> ArgumentEncoder for ($($typename,)*)
+        where
+            $( $typename: CandidType ),*
+        {
+            fn encode(self, ser: &mut IDLBuilder) -> Result<()> {
+                let ( $( $id, )* ) = self;
+                $(
+                ser.arg(&$id)?;
+                )*
+
+                Ok(())
+            }
+        }
+    }
+}
+
+decode_impl!(a: A);
+decode_impl!(a: A, b: B);
+decode_impl!(a: A, b: B, c: C);
+decode_impl!(a: A, b: B, c: C, d: D);
+decode_impl!(a: A, b: B, c: C, d: D, e: E);
+decode_impl!(a: A, b: B, c: C, d: D, e: E, f: F);
+decode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G);
+decode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H);
+decode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I);
+decode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J);
+#[rustfmt::skip]
+decode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K);
+#[rustfmt::skip]
+decode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L);
+#[rustfmt::skip]
+decode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M);
+#[rustfmt::skip]
+decode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N);
+#[rustfmt::skip]
+decode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O);
+#[rustfmt::skip]
+decode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O, p: P);
+
+encode_impl!(a: A);
+encode_impl!(a: A, b: B);
+encode_impl!(a: A, b: B, c: C);
+encode_impl!(a: A, b: B, c: C, d: D);
+encode_impl!(a: A, b: B, c: C, d: D, e: E);
+encode_impl!(a: A, b: B, c: C, d: D, e: E, f: F);
+encode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G);
+encode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H);
+encode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I);
+encode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J);
+#[rustfmt::skip]
+encode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K);
+#[rustfmt::skip]
+encode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L);
+#[rustfmt::skip]
+encode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M);
+#[rustfmt::skip]
+encode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N);
+#[rustfmt::skip]
+encode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O);
+#[rustfmt::skip]
+encode_impl!(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H, i: I, j: J, k: K, l: L, m: M, n: N, o: O, p: P);
diff --git a/rust/candid/tests/serde.rs b/rust/candid/tests/serde.rs
index bfe1c90e..ab5a8f2a 100644
--- a/rust/candid/tests/serde.rs
+++ b/rust/candid/tests/serde.rs
@@ -1,38 +1,33 @@
+#![allow(clippy::unit_cmp)]
 use candid::{decode_one, encode_one, CandidType, Decode, Deserialize, Encode, Int, Nat};
 
 #[test]
 fn test_error() {
-    check_error(
-        || test_decode(b"DID", &42),
-        "wrong magic number [68, 73, 68, 0]",
-    );
-    check_error(
-        || test_decode(b"DIDL", &42),
-        "leb128::read::Error: failed to fill whole buffer",
-    );
+    check_error(|| test_decode(b"DID", &42), "io error");
+    check_error(|| test_decode(b"DIDL", &42), "len at byte offset 4");
     check_error(
         || test_decode(b"DIDL\0\0", &42),
-        "No more values to deserialize",
+        "No more values on the wire",
     );
     check_error(
         || test_decode(b"DIDL\x01\x7c", &42),
-        "Unsupported op_code -4 in type table",
+        "Unknown opcode at byte offset 5",
     );
     // Infinite loop are prevented by design
     check_error(
         || test_decode(b"DIDL\x02\x6e\x01\0", &42),
-        "Unsupported op_code 0 in type table",
+        "Unknown opcode at byte offset 7",
     );
     check_error(
         || test_decode(b"DIDL\0\x01\x7e\x01\x01", &true),
         "Trailing value after finishing deserialization",
     );
+    check_error(|| test_decode(b"DIDL\0\x01\x7e", &true), "io error");
+    // Out of bounds type index
     check_error(
-        || test_decode(b"DIDL\0\x01\x7e", &true),
-        "io error: failed to fill whole buffer",
+        || test_decode(b"DIDL\0\x01\0\x01", &42),
+        "type index 0 out of range",
     );
-    // Out of bounds type index
-    check_error(|| test_decode(b"DIDL\0\x01\0\x01", &42), "unknown type 0");
 }
 
 #[test]
@@ -68,7 +63,7 @@ fn test_integer() {
     );
     check_error(
         || test_decode(&hex("4449444c00017c2a"), &42i64),
-        "Type mismatch. Type on the wire: Int; Expected type: Int64",
+        "int is not a subtype of int64",
     );
 }
 
@@ -111,7 +106,7 @@ fn test_text() {
 fn test_reserved() {
     use candid::{Empty, Reserved};
     all_check(Reserved, "4449444c000170");
-    test_decode(&hex("4449444c00017b2a"), &candid::Reserved);
+    test_decode(&hex("4449444c00017c2a"), &candid::Reserved);
     test_decode(
         &hex("4449444c016c02d3e3aa027e868eb7027c0100012a"),
         &candid::Reserved,
@@ -184,7 +179,7 @@ fn test_struct() {
                 },
             )
         },
-        "field hash out of u32",
+        "field id out of 32-bit range",
     );
 
     #[derive(PartialEq, Debug, Deserialize, CandidType)]
@@ -303,23 +298,22 @@ fn test_extra_fields() {
     test_decode(&bytes, &a1);
     // Cannot Decode A1 to A2
     let bytes = encode(&a1);
-    check_error(|| test_decode(&bytes, &a2), "missing field `baz`");
+    check_error(|| test_decode(&bytes, &a2), "field bab");
 
     #[derive(PartialEq, Debug, Deserialize, CandidType)]
     enum E2 {
         Foo,
-        Bar(A1, A2),
+        Bar,
         Baz,
     }
-    // E1, E2 can be used interchangably as long as the variant matches
     let bytes = encode(&E1::Foo);
     test_decode(&bytes, &E2::Foo);
+
     let bytes = encode(&E2::Foo);
-    test_decode(&bytes, &E1::Foo);
-    let bytes = encode(&E2::Baz);
+    test_decode(&bytes, &Some(E2::Foo));
     check_error(
-        || test_decode(&bytes, &E1::Bar),
-        "Unknown variant hash 3303867",
+        || test_decode(&bytes, &E1::Foo),
+        "Variant field 3_303_867 not found",
     );
 }
 
@@ -466,7 +460,7 @@ fn test_tuple() {
                 &(Int::from(42), "💩"),
             )
         },
-        "Expect vector index 1, but get 2",
+        "field 1: text is only in the expected type",
     );
 }
 
@@ -480,12 +474,12 @@ fn test_variant() {
     all_check(Unit::Bar, "4449444c016b02b3d3c9017fe6fdd5017f010000");
     check_error(
         || test_decode(&hex("4449444c016b02b3d3c9017fe6fdd5017f010003"), &Unit::Bar),
-        "variant index 3 larger than length 2",
+        "Variant index 3 larger than length 2",
     );
 
     check_error(
         || test_decode(&hex("4449444c016b02b4d3c9017fe6fdd5017f010000"), &Unit::Bar),
-        "Unknown variant hash 3303860",
+        "Variant field 3_303_860 not found",
     );
 
     let res: Result<String, String> = Ok("good".to_string());
@@ -580,11 +574,18 @@ fn test_multiargs() {
     assert_eq!(tuple.0, [(42.into(), "text")]);
     assert_eq!(tuple.1, (42.into(), "text".to_string()));
 
-    let err = || {
-        Decode!(&bytes, Vec<(Int, &str)>, (Int, String), i32).unwrap();
-        true
-    };
-    check_error(err, "No more values to deserialize");
+    let tuple = Decode!(
+        &bytes,
+        Vec<(Int, &str)>,
+        (Int, String),
+        Option<i32>,
+        (),
+        candid::Reserved
+    )
+    .unwrap();
+    assert_eq!(tuple.2, None);
+    assert_eq!(tuple.3, ());
+    assert_eq!(tuple.4, candid::Reserved);
 }
 
 fn hex(bytes: &str) -> Vec<u8> {
@@ -614,7 +615,7 @@ where
 
 fn test_decode<'de, T>(bytes: &'de [u8], expected: &T)
 where
-    T: PartialEq + serde::de::Deserialize<'de> + std::fmt::Debug,
+    T: PartialEq + serde::de::Deserialize<'de> + std::fmt::Debug + CandidType,
 {
     let decoded_one = decode_one::<T>(bytes).unwrap();
     let decoded_macro = Decode!(bytes, T).unwrap();
diff --git a/rust/candid/tests/value.rs b/rust/candid/tests/value.rs
index e5ff77d3..1399fad8 100644
--- a/rust/candid/tests/value.rs
+++ b/rust/candid/tests/value.rs
@@ -28,7 +28,8 @@ type List = List1;
 type List1 = List2;
 type List2 = opt record { head: int16; tail: List1 };
 type byte = nat8;
-type f = func (byte, int, nat, int8) -> (List);
+type enum = variant { a: nat; b: text; c };
+type f = func (byte, int, nat, int8) -> (List, enum);
 service : {
   f : f;
 }
@@ -47,20 +48,20 @@ service : {
                 IDLValue::Nat8(42),
                 IDLValue::Int(42.into()),
                 IDLValue::Nat(42.into()),
-                IDLValue::Int8(42)
+                IDLValue::Int8(42),
             ]
         );
     }
     {
-        let str = "(opt record { head = 1000; tail = opt record {head = -2000; tail = null}})";
+        let str = "(opt record { head = 1000; tail = opt record {head = -2000; tail = null}}, variant {a = 42})";
         let args = str.parse::<IDLArgs>().unwrap();
         let encoded = args.to_bytes_with_types(&env, &method.rets).unwrap();
         let decoded = IDLArgs::from_bytes(&encoded).unwrap();
-        assert_eq!(decoded.to_string(), "(\n  opt record {\n    1_158_359_328 = 1_000;\n    1_291_237_008 = opt record { 1_158_359_328 = -2_000; 1_291_237_008 = null };\n  },\n)");
+        assert_eq!(decoded.to_string(), "(\n  opt record {\n    1_158_359_328 = 1_000;\n    1_291_237_008 = opt record { 1_158_359_328 = -2_000; 1_291_237_008 = null };\n  },\n  variant { 97 = 42 },\n)");
         let decoded = IDLArgs::from_bytes_with_types(&encoded, &env, &method.rets).unwrap();
         assert_eq!(
             decoded.to_string(),
-            "(opt record { head = 1_000; tail = opt record { head = -2_000; tail = null } })"
+            "(\n  opt record { head = 1_000; tail = opt record { head = -2_000; tail = null } },\n  variant { a = 42 },\n)"
         );
         let decoded = IDLArgs::from_bytes_with_types(&encoded, &env, &[]).unwrap();
         assert_eq!(decoded.to_string(), "()");
diff --git a/test/construct.test.did b/test/construct.test.did
index 4a2730ac..d8c5b48c 100644
--- a/test/construct.test.did
+++ b/test/construct.test.did
@@ -45,14 +45,16 @@ assert blob "DIDL\02\6e\01\6e\7c\01\00\01\01\2a" == "(opt opt 42)"   : (opt opt
 assert blob "DIDL\01\6e\00\01\00\01\01\00" == "(opt opt null)"       : (Opt) "opt: recursion";
 assert blob "DIDL\01\6e\00\01\00\01\01\00" == "(opt opt null)"       : (opt opt opt empty) "opt: non-recurisve type";
 assert blob "DIDL\02\6e\01\6e\00\01\00\01\01\00" == "(opt opt null)" : (Opt) "opt: mutual recursion";
+assert blob "DIDL\00\00" == "(null)"                                 : (Opt) "opt: extra arg";
 
 // vector
 assert blob "DIDL\01\6d\7c\01\00\00" == "(vec {})"                          : (vec int) "vec: empty";
+assert blob "DIDL\01\6d\7c\01\00\00"                                       !: (vec int8) "vec: non subtype empty";
 assert blob "DIDL\01\6d\7c\01\00\02\01\02" == "(vec { 1; 2 })"              : (vec int) "vec";
 assert blob "DIDL\01\6d\7b\01\00\02\01\02" == "(blob \"\\01\\02\")"         : (vec nat8) "vec: blob";
 assert blob "DIDL\01\6d\00\01\00\00" == "(vec {})"                          : (Vec) "vec: recursive vector";
 assert blob "DIDL\01\6d\00\01\00\02\00\00" == "(vec { vec {}; vec {} })"    : (Vec) "vec: tree";
-assert blob "DIDL\01\6d\00\01\00\02\00\00" == "(vec { vec {}; vec {} })"    : (vec vec empty) "vec: non-recursive tree";
+assert blob "DIDL\01\6d\00\01\00\02\00\00" == "(vec { vec {}; vec {} })"    : (vec vec opt empty) "vec: non-recursive tree";
 assert blob "DIDL\01\6d\7f\01\00\e8\07"                                     : (vec null) "vec: space bomb";
 assert "(vec { 1; -1 })"                                                   !: (vec nat) "vec: type mismatch";
 assert blob "DIDL\01\6d\7c\01\00"                                          !: (vec int) "vec: too short";
@@ -64,9 +66,12 @@ assert blob "DIDL\02\6d\01\6c\00\01\00\05"                                  : (v
 assert blob "DIDL\01\6c\00\01\00" == "(record {})"                                : (record {}) "record: empty";
 assert blob "DIDL\01\6c\00\03\00\00\00" == "(record {}, record {}, record {})"    : (record {}, record {}, record {}) "record: multiple records";
 assert blob "DIDL\01\6c\01\01\7c\01\00\2a" == "(record { 1 = 42 })"               : (record {1:int}) "record";
+assert blob "DIDL\01\6c\01\01\7c\01\00\2a" == "(record { 1 = opt 42 })"           : (record {1:opt int}) "record: opt";
+assert blob "DIDL\01\6c\01\01\7c\01\00\2a" == "(record { 1 = null })"             : (record {1:reserved}) "record: reserved";
 assert blob "DIDL\01\6c\01\01\7c\01\00\2a" == "(record {})"                       : (record {}) "record: ignore fields";
 assert "(record { whatever = 0 })"  == "(record {})"                              : (record {}) "record: ignore fields (textual)";
 assert blob "DIDL\01\6c\01\01\7c\01\00\2a"                                       !: (record {2:int}) "record: missing field";
+assert blob "DIDL\01\6c\01\01\7c\01\00\2a" == "(record { 2 = null })"             : (record {2:opt int}) "record: missing opt field";
 assert blob "DIDL\01\6c\02\00\7c\01\7e\01\00\2a\01" == "(record {42; true})"      : (record {int; bool}) "record: tuple";
 assert blob "DIDL\01\6c\02\00\7c\01\7e\01\00\2a\01" == "(record {1 = true})"      : (record {1:bool}) "record: ignore fields";
 assert blob "DIDL\01\6c\02\00\7c\01\7e\01\00\2a\01"                              !: (record {bool; int}) "record: type mismatch";
@@ -95,6 +100,7 @@ assert blob "DIDL\01\6e\7e\01\00\00" == "(null)"
 assert blob "DIDL\01\6e\7e\01\00\01\00" == "(opt false)"                        : (opt bool) "opt: parsing opt false : opt bool";
 assert blob "DIDL\01\6e\7e\01\00\01\01" == "(opt true)"                         : (opt bool) "opt: parsing opt true : opt bool";
 assert blob "DIDL\01\6e\7e\01\00\01\02"                                        !: (opt bool) "opt: parsing invalid bool at opt bool";
+assert blob "DIDL\00\00" == "(null)"                                            : (opt bool) "opt: extra value";
 
 // nested opt
 assert blob "DIDL\02\6e\01\6e\7e\01\00\00" == "(null)"                          : (opt opt bool) "opt: parsing null : opt opt bool";
@@ -128,10 +134,11 @@ assert "(variant {})"                                                          !
 assert blob "DIDL\01\6b\00\01\00"                                              !: (variant {}) "variant: no empty value";
 assert blob "DIDL\01\6b\01\00\7f\01\00\00" == "(variant {0})"                   : (variant {0}) "variant: numbered field";
 assert blob "DIDL\01\6b\01\00\7f\01\00\00\2a"                                  !: (variant {0:int}) "variant: type mismatch";
-assert blob "DIDL\01\6b\02\00\7f\01\7c\01\00\01\2a"                             : (variant {0:int; 1:int}) "variant: type mismatch in unused tag";
+assert blob "DIDL\01\6b\02\00\7f\01\7c\01\00\01\2a"                            !: (variant {0:int; 1:int}) "variant: type mismatch in unused tag";
 assert blob "DIDL\01\6b\01\00\7f\01\00\00" == "(variant {0})"                   : (variant {0;1}) "variant: ignore field";
-assert blob "DIDL\01\6b\02\00\7f\01\7f\01\00\00" == "(variant {0})"             : (variant {0}) "variant: ignore field";
-assert blob "DIDL\01\6b\02\00\7f\01\7f\01\00\01" == "(variant {1})"             : (variant {1;2}) "variant: change index";
+assert blob "DIDL\01\6b\02\00\7f\01\7f\01\00\00"                               !: (variant {0}) "variant {0;1} !<: variant {0}";
+assert blob "DIDL\01\6b\02\00\7f\01\7f\01\00\00" == "(null)"                    : (opt variant {0}) "variant {0;1} <: opt variant {0}";
+assert blob "DIDL\01\6b\02\00\7f\01\7f\01\00\01" == "(variant {1})"             : (variant {0;1;2}) "variant: change index";
 assert blob "DIDL\01\6b\01\00\7f\01\00\00"                                     !: (variant {1}) "variant: missing field";
 assert blob "DIDL\01\6b\01\00\7f\01\00\01"                                     !: (variant {0}) "variant: index out of range";
 assert blob "DIDL\01\6b\02\00\7f\00\7f\01\00\00"                               !: (variant {0}) "variant: duplicate fields";
@@ -175,6 +182,11 @@ assert blob "DIDL\02\6b\02\d1\a7\cf\02\7f\f1\f3\92\8e\04\01\6c\02\a0\d2\ac\a8\04
 assert blob "DIDL\02\6b\02\d1\a7\cf\02\7f\f1\f3\92\8e\04\01\6c\02\a0\d2\ac\a8\04\7c\90\ed\da\e7\04\00\01\00\01\01\01\02\00"
     == "(variant { cons = record { head = 1; tail = variant { cons = record { head = 2; tail = variant { nil } } } } })" : (VariantList) "variant: list";
 
+assert blob "DIDL\02\6b\02\d1\a7\cf\02\7f\f1\f3\92\8e\04\01\6c\02\a0\d2\ac\a8\04\7c\90\ed\da\e7\04\00\01\00\00"
+    == "(variant {nil}, null, null, null, null)" : (VariantList, opt VariantList, null, reserved, opt int) "variant: extra args";
+
+assert blob "DIDL\02\6b\02\d1\a7\cf\02\7f\f1\f3\92\8e\04\01\6c\02\a0\d2\ac\a8\04\7c\90\ed\da\e7\04\00\01\00\00" !: (VariantList, opt int, vec int) "non-null extra args";
+
 // skip fields
 assert blob "DIDL\07\6c\07\c3\e3\aa\02\01\d3\e3\aa\02\7e\d5\e3\aa\02\02\db\e3\aa\02\01\a2\e5\aa\02\04\bb\f1\aa\02\06\86\8e\b7\02\75\6c\02\d3\e3\aa\02\7e\86\8e\b7\02\75\6b\02\d1\a7\cf\02\7f\f1\f3\92\8e\04\03\6c\02\a0\d2\ac\a8\04\7c\90\ed\da\e7\04\02\6e\05\6c\02\a0\d2\ac\a8\04\7c\90\ed\da\e7\04\04\6b\02\d3\e3\aa\02\7f\86\8e\b7\02\7f\01\00\01\0b\00\00\00\01\00\00\0a\00\00\00\01\14\00\00\2a\00\00\00" == "(record { foo = 42; bar = true; bat = variant { nil }; baz = record { foo = 10; bar = false }; bbb = opt record { head = 20; tail = null }; bib = variant { bar }; bab = record { foo = 11; bar = true}})" : (A2);
 
@@ -182,7 +194,7 @@ assert blob "DIDL\07\6c\07\c3\e3\aa\02\01\d3\e3\aa\02\7e\d5\e3\aa\02\02\db\e3\aa
 
 assert blob "DIDL\07\6c\07\c3\e3\aa\02\01\d3\e3\aa\02\7e\d5\e3\aa\02\02\db\e3\aa\02\01\a2\e5\aa\02\04\bb\f1\aa\02\06\86\8e\b7\02\75\6c\02\d3\e3\aa\02\7e\86\8e\b7\02\75\6b\02\d1\a7\cf\02\7f\f1\f3\92\8e\04\03\6c\02\a0\d2\ac\a8\04\7c\90\ed\da\e7\04\02\6e\05\6c\02\a0\d2\ac\a8\04\7c\90\ed\da\e7\04\04\6b\02\d3\e3\aa\02\7f\86\8e\b7\02\7f\01\00\01\0b\00\00\00\01\00\00\0a\00\00\00\01\14\00\00\2a\00\00\00" == "(record { bar = true; baz = record { bar = false }; bbb = opt record { head = 20 }})" : (record { bar: bool; baz: record { bar: bool }; bbb: opt record { head : int} }) "skip fields";
 
-assert blob "DIDL\07\6c\07\c3\e3\aa\02\01\d3\e3\aa\02\7e\d5\e3\aa\02\02\db\e3\aa\02\01\a2\e5\aa\02\04\bb\f1\aa\02\06\86\8e\b7\02\75\6c\02\d3\e3\aa\02\7e\86\8e\b7\02\75\6b\02\d1\a7\cf\02\7f\f1\f3\92\8e\04\03\6c\02\a0\d2\ac\a8\04\7c\90\ed\da\e7\04\02\6e\05\6c\02\a0\d2\ac\a8\04\7c\90\ed\da\e7\04\04\6b\02\d3\e3\aa\02\7f\86\8e\b7\02\7f\01\00\01\0b\00\00\00\01\00\00\0a\00\00\00\01\14\00\00\2a\00\00\00" == "(record { bat = variant { nil } })" : (record { bat: variant { nil; new_field: empty } }) "new variant field";
+assert blob "DIDL\07\6c\07\c3\e3\aa\02\01\d3\e3\aa\02\7e\d5\e3\aa\02\02\db\e3\aa\02\01\a2\e5\aa\02\04\bb\f1\aa\02\06\86\8e\b7\02\75\6c\02\d3\e3\aa\02\7e\86\8e\b7\02\75\6b\02\d1\a7\cf\02\7f\f1\f3\92\8e\04\03\6c\02\a0\d2\ac\a8\04\7c\90\ed\da\e7\04\02\6e\05\6c\02\a0\d2\ac\a8\04\7c\90\ed\da\e7\04\04\6b\02\d3\e3\aa\02\7f\86\8e\b7\02\7f\01\00\01\0b\00\00\00\01\00\00\0a\00\00\00\01\14\00\00\2a\00\00\00" == "(record { bat = variant { nil } })" : (record { bat: variant { nil; cons: record { head : int; tail : VariantList }; new_field: empty } }) "new variant field";
 
 assert blob "DIDL\07\6c\07\c3\e3\aa\02\01\d3\e3\aa\02\7e\d5\e3\aa\02\02\db\e3\aa\02\01\a2\e5\aa\02\04\bb\f1\aa\02\06\86\8e\b7\02\75\6c\02\d3\e3\aa\02\7e\86\8e\b7\02\75\6b\02\d1\a7\cf\02\7f\f1\f3\92\8e\04\03\6c\02\a0\d2\ac\a8\04\7c\90\ed\da\e7\04\02\6e\05\6c\02\a0\d2\ac\a8\04\7c\90\ed\da\e7\04\04\6b\02\d3\e3\aa\02\7f\86\8e\b7\02\7f\01\00\01\0b\00\00\00\01\00\00\0a\00\00\00\01\14\00\00\2a\00\00\00" !: (record { foo: int; new_field: bool }) "new record field";
 
diff --git a/test/prim.test.did b/test/prim.test.did
index 2035f9ec..f73cf528 100644
--- a/test/prim.test.did
+++ b/test/prim.test.did
@@ -21,7 +21,7 @@ assert blob "DIDL\00\01\5e" !: () "Out of range type";
 assert blob "DIDL\00\01\7f"     : (null);
 assert blob "DIDL\00\01\7e"    !: (null) "wrong type";
 assert blob "DIDL\00\01\7f\00" !: (null) "null: too long";
-assert blob "DIDL\00\00"       !: (null) "null: missing";
+assert blob "DIDL\00\00"        : (null) "null: extra null values";
 
 assert blob "DIDL\00\01\7e\00" == "(false)" : (bool) "bool: false";
 assert blob "DIDL\00\01\7e\01" == "(true)"  : (bool) "bool: true";
@@ -178,8 +178,9 @@ assert blob "DIDL\00\01\70" == blob "DIDL\00\01\7f"          : (reserved) "reser
 assert blob "DIDL\00\01\70" == blob "DIDL\00\01\7e\01"       : (reserved) "reserved from bool";
 assert blob "DIDL\00\01\70" == blob "DIDL\00\01\7d\80\01"    : (reserved) "reserved from nat";
 assert blob "DIDL\00\01\70" == blob "DIDL\00\01\71\06Motoko" : (reserved) "reserved from text";
+assert blob "DIDL\00\00"                                     : (reserved) "reserved extra value";
 assert blob "DIDL\00\01\71\05Motoko"    !: (reserved) "reserved from too short text";
-assert blob "DIDL\00\01\71\03\e2\28\a1" !: (reserved) "reserved from invalid utf8 text"; // Do we really require this to fail?
+assert blob "DIDL\00\01\71\03\e2\28\a1" !: (reserved) "reserved from invalid utf8 text";
 
 assert blob "DIDL\00\01\6f"                      !: (empty) "cannot decode empty type";
 assert blob "DIDL\01\6e\6f\01\00\00" == "(null)"  : (opt empty) "okay to decode non-empty value";
diff --git a/test/reference.test.did b/test/reference.test.did
index c0a90dfd..8f01fb44 100644
--- a/test/reference.test.did
+++ b/test/reference.test.did
@@ -55,9 +55,9 @@ assert blob "DIDL\00\01\6a\01\03\ca\ff\ee\01\61"    !: (func () -> ()) "func: no
 assert blob "DIDL\01\6a\01\69\01\7d\00\01\00\01\01\03\ca\ff\ee\03foo" !: (func (service {}) -> (nat)) "func: service not in type table";
 assert blob "DIDL\01\6a\01\71\01\7d\01\03\01\00\01\01\03\ca\ff\ee\03foo" !: (func (text) -> (nat)) "func: invalid annotation";
 
-// coercion does not look at type table
-assert blob "DIDL\01\69\00\01\00\01\03\ca\ff\ee" == "(service \"w7x7r-cok77-xa\")" : (service { foo : (text) -> (nat) }) "service {} decodes at service { foo : (text) -> (nat) }";
+// subtype
+assert blob "DIDL\01\69\00\01\00\01\03\ca\ff\ee"    !: (service { foo : (text) -> (nat) }) "service {} !<: service { foo : (text) -> (nat) }";
 assert blob "DIDL\02\6a\01\71\01\7d\00\69\01\03foo\00\01\01\01\03\ca\ff\ee" == "(service \"w7x7r-cok77-xa\")" : (service {}) "service { foo : (text) -> (nat) } decodes at service {}";
 
-assert blob "DIDL\01\6a\00\00\00\01\00\01\01\03\ca\ff\ee\03foo" == "(func \"w7x7r-cok77-xa\".foo)" : (func (text) -> (nat)) "func () -> () decodes at func (text) -> (nat) }";
-assert blob "DIDL\01\6a\01\71\01\7d\00\01\00\01\01\03\ca\ff\ee\03foo" == "(func \"w7x7r-cok77-xa\".foo)" : (func () -> ()) "func (text) -> (nat) decodes at func () -> () }";
+assert blob "DIDL\01\6a\00\00\00\01\00\01\01\03\ca\ff\ee\03foo" !: (func (text) -> (nat)) "func () -> () !<: (text) -> (nat) }";
+assert blob "DIDL\01\6a\01\71\01\7d\00\01\00\01\01\03\ca\ff\ee\03foo" == "(func \"w7x7r-cok77-xa\".foo)" : (func (text, opt text) -> ()) "func (text) -> (nat) decodes at func () -> () }";
diff --git a/tools/didc/src/main.rs b/tools/didc/src/main.rs
index 936dd5dd..1903c013 100644
--- a/tools/didc/src/main.rs
+++ b/tools/didc/src/main.rs
@@ -18,8 +18,8 @@ enum Command {
     Check {
         /// Specifies did file for type checking
         input: PathBuf,
-        /// Specifies a second did file for subtyping check
-        upgrade: Option<PathBuf>,
+        /// Specifies a previous version of did file for subtyping check
+        previous: Option<PathBuf>,
     },
     /// Generate binding for different languages
     Bind {
@@ -164,18 +164,16 @@ fn check_file(env: &mut TypeEnv, file: &Path) -> candid::Result<Option<Type>> {
 
 fn main() -> Result<()> {
     match Command::from_args() {
-        Command::Check { input, upgrade } => {
+        Command::Check { input, previous } => {
             let mut env = TypeEnv::new();
             let opt_t1 = check_file(&mut env, &input)?;
-            if let Some(upgrade) = upgrade {
+            if let Some(previous) = previous {
                 let mut env2 = TypeEnv::new();
-                let opt_t2 = check_file(&mut env2, &upgrade)?;
+                let opt_t2 = check_file(&mut env2, &previous)?;
                 match (opt_t1, opt_t2) {
                     (Some(t1), Some(t2)) => {
                         let mut gamma = HashSet::new();
-                        let res =
-                            candid::types::subtype::subtype(&mut gamma, &env, &t1, &env2, &t2);
-                        println!("{}", res);
+                        candid::types::subtype::subtype(&mut gamma, &env, &t1, &env2, &t2)?;
                     }
                     _ => {
                         bail!("did file need to contain the main service type for subtyping check")
@@ -190,8 +188,7 @@ fn main() -> Result<()> {
             }
             let ty1 = env.ast_to_type(&ty1)?;
             let ty2 = env.ast_to_type(&ty2)?;
-            let res = candid::types::subtype::subtype(&mut HashSet::new(), &env, &ty1, &env, &ty2);
-            println!("{}", res);
+            candid::types::subtype::subtype(&mut HashSet::new(), &env, &ty1, &env, &ty2)?;
         }
         Command::Bind { input, target } => {
             let mut env = TypeEnv::new();