From 1c00b4af7ce33dcaf8399e829caafd671c3de397 Mon Sep 17 00:00:00 2001
From: Yan Chen <48968912+chenyan-dfinity@users.noreply.github.com>
Date: Thu, 16 Nov 2023 09:35:31 -0800
Subject: [PATCH] Release candid 0.10 (#493)

---
 .github/workflows/bench.yml                   |   2 +-
 .github/workflows/rust.yml                    |   8 +-
 Cargo.lock                                    | 373 +++++------
 Cargo.toml                                    |  12 +
 Changelog.md                                  |  34 +-
 rust/candid/Cargo.toml                        |  94 +--
 rust/candid/benches/benchmark.rs              |   5 +-
 rust/candid/fuzz/Cargo.lock                   | 597 ++----------------
 rust/candid/fuzz/Cargo.toml                   |   2 +-
 rust/candid/fuzz/fuzz_targets/type_decoder.rs |   4 +-
 rust/candid/src/binary_parser.rs              |  16 +-
 rust/candid/src/bindings/mod.rs               |  20 -
 rust/candid/src/de.rs                         | 106 +++-
 rust/candid/src/error.rs                      | 168 ++---
 rust/candid/src/lib.rs                        | 156 +----
 rust/candid/src/parser/grammar.rs             |   2 -
 rust/candid/src/parser/mod.rs                 |  36 --
 .../candid/src/{bindings => pretty}/candid.rs |  46 +-
 rust/candid/src/pretty/mod.rs                 |   4 +
 .../candid/src/{pretty.rs => pretty/utils.rs} |   7 +-
 rust/candid/src/ser.rs                        |  33 +-
 rust/candid/src/types/arc.rs                  |   5 +-
 rust/candid/src/types/impls.rs                |  12 +-
 rust/candid/src/types/internal.rs             | 102 +--
 rust/candid/src/types/leb128.rs               | 100 +++
 rust/candid/src/types/mod.rs                  |  10 +
 rust/candid/src/types/number.rs               | 121 +---
 rust/candid/src/types/principal.rs            | 354 +----------
 rust/candid/src/types/rc.rs                   |   5 +-
 rust/candid/src/types/subtype.rs              |  94 ++-
 rust/candid/src/types/type_env.rs             |  20 +-
 rust/candid/src/types/value.rs                |  59 +-
 rust/candid/src/utils.rs                      | 103 +--
 rust/candid/tests/number.rs                   |  69 +-
 rust/candid/tests/serde.rs                    |   8 +-
 rust/candid/tests/types.rs                    |  48 +-
 rust/candid_derive/Cargo.toml                 |   2 +-
 rust/candid_derive/src/func.rs                |   8 +-
 rust/candid_derive/src/lib.rs                 |   2 +-
 rust/candid_parser/Cargo.toml                 |  57 ++
 rust/candid_parser/LICENSE                    |   1 +
 rust/{candid => candid_parser}/build.rs       |   3 +-
 .../src/bindings/analysis.rs                  |   2 +-
 .../src/bindings/javascript.rs                |  33 +-
 rust/candid_parser/src/bindings/mod.rs        |   8 +
 .../src/bindings/motoko.rs                    |  20 +-
 .../src/bindings/rust.rs                      |  44 +-
 .../src/bindings/typescript.rs                |  22 +-
 .../parser => candid_parser/src}/configs.rs   |   2 +-
 rust/candid_parser/src/error.rs               | 126 ++++
 .../src}/grammar.lalrpop                      |  15 +-
 rust/candid_parser/src/grammar.rs             |   2 +
 rust/candid_parser/src/lib.rs                 | 152 +++++
 .../parser => candid_parser/src}/random.rs    | 117 ++--
 .../src/parser => candid_parser/src}/test.rs  |  10 +-
 .../src/parser => candid_parser/src}/token.rs |   0
 .../src/parser => candid_parser/src}/types.rs |   2 +-
 .../parser => candid_parser/src}/typing.rs    |  20 +-
 rust/candid_parser/src/utils.rs               |  82 +++
 .../tests/assets/actor.did                    |   0
 .../tests/assets/bad_comment.did              |   0
 .../tests/assets/bad_import.did               |   0
 .../tests/assets/class.did                    |   0
 .../tests/assets/codegen/basic/invalid_id.did |   0
 .../tests/assets/codegen/basic/invalid_id.rs  |   0
 .../tests/assets/codegen/basic/prim_types.did |   0
 .../tests/assets/codegen/basic/prim_types.rs  |   0
 .../tests/assets/codegen/basic/recursive.did  |   0
 .../tests/assets/codegen/basic/recursive.rs   |   0
 .../assets/codegen/examples/linkedup.did      |   0
 .../tests/assets/codegen/examples/linkedup.rs |   0
 .../tests/assets/collision_fields.did         |   0
 .../tests/assets/collision_fields2.did        |   0
 .../tests/assets/comment.did                  |   0
 .../tests/assets/cyclic.did                   |   0
 rust/candid_parser/tests/assets/empty.did     |   6 +
 .../tests/assets/escape.did                   |   0
 .../tests/assets/example.did                  |   0
 .../tests/assets/fieldnat.did                 |   0
 .../tests/assets/import/a.did                 |   0
 .../tests/assets/import/b/b.did               |   0
 .../tests/assets/invalid_cyclic.did           |   0
 .../tests/assets/keyword.did                  |   0
 .../tests/assets/management.did               |   0
 .../tests/assets/not_func.did                 |   0
 .../tests/assets/not_serv.did                 |   0
 .../tests/assets/ok/actor.d.ts                |   0
 .../tests/assets/ok/actor.did                 |   0
 .../tests/assets/ok/actor.js                  |   0
 .../tests/assets/ok/actor.mo                  |   0
 .../tests/assets/ok/actor.rs                  |   0
 .../tests/assets/ok/bad_comment.fail          |   0
 .../tests/assets/ok/bad_import.fail           |   0
 .../tests/assets/ok/class.d.ts                |   0
 .../tests/assets/ok/class.did                 |   0
 .../tests/assets/ok/class.js                  |   0
 .../tests/assets/ok/class.mo                  |   0
 .../tests/assets/ok/class.rs                  |   0
 .../tests/assets/ok/collision_fields.fail     |   0
 .../tests/assets/ok/collision_fields2.fail    |   0
 .../tests/assets/ok/comment.d.ts              |   0
 .../tests/assets/ok/comment.did               |   0
 .../tests/assets/ok/comment.js                |   0
 .../tests/assets/ok/comment.mo                |   0
 .../tests/assets/ok/comment.rs                |   0
 .../tests/assets/ok/cyclic.d.ts               |   0
 .../tests/assets/ok/cyclic.did                |   0
 .../tests/assets/ok/cyclic.js                 |   0
 .../tests/assets/ok/cyclic.mo                 |   0
 .../tests/assets/ok/cyclic.rs                 |   0
 rust/candid_parser/tests/assets/ok/empty.d.ts |  11 +
 rust/candid_parser/tests/assets/ok/empty.did  |   6 +
 rust/candid_parser/tests/assets/ok/empty.js   |  14 +
 rust/candid_parser/tests/assets/ok/empty.mo   |  11 +
 rust/candid_parser/tests/assets/ok/empty.rs   |  35 +
 .../tests/assets/ok/escape.d.ts               |   0
 .../tests/assets/ok/escape.did                |   0
 .../tests/assets/ok/escape.js                 |   0
 .../tests/assets/ok/escape.rs                 |   0
 .../tests/assets/ok/example.d.ts              |   0
 .../tests/assets/ok/example.did               |   0
 .../tests/assets/ok/example.js                |   0
 .../tests/assets/ok/example.mo                |   0
 .../tests/assets/ok/example.rs                |   0
 .../tests/assets/ok/fieldnat.d.ts             |   0
 .../tests/assets/ok/fieldnat.did              |   0
 .../tests/assets/ok/fieldnat.js               |   0
 .../tests/assets/ok/fieldnat.mo               |   0
 .../tests/assets/ok/fieldnat.rs               |   0
 .../tests/assets/ok/invalid_cyclic.fail       |   0
 .../tests/assets/ok/keyword.d.ts              |   0
 .../tests/assets/ok/keyword.did               |   0
 .../tests/assets/ok/keyword.js                |   0
 .../tests/assets/ok/keyword.mo                |   0
 .../tests/assets/ok/keyword.rs                |   0
 .../tests/assets/ok/management.d.ts           |   0
 .../tests/assets/ok/management.did            |   0
 .../tests/assets/ok/management.js             |   0
 .../tests/assets/ok/management.mo             |   0
 .../tests/assets/ok/management.rs             |   0
 .../tests/assets/ok/not_func.fail             |   0
 .../tests/assets/ok/not_serv.fail             |   0
 .../tests/assets/ok/oneway.fail               |   0
 .../tests/assets/ok/recursion.d.ts            |   0
 .../tests/assets/ok/recursion.did             |   0
 .../tests/assets/ok/recursion.js              |   0
 .../tests/assets/ok/recursion.mo              |   0
 .../tests/assets/ok/recursion.rs              |   0
 .../tests/assets/ok/recursive_class.d.ts      |   0
 .../tests/assets/ok/recursive_class.did       |   0
 .../tests/assets/ok/recursive_class.js        |   0
 .../tests/assets/ok/recursive_class.mo        |   0
 .../tests/assets/ok/recursive_class.rs        |   0
 .../tests/assets/ok/service.d.ts              |   0
 .../tests/assets/ok/service.did               |   0
 .../tests/assets/ok/service.js                |   0
 .../tests/assets/ok/service.mo                |   0
 .../tests/assets/ok/service.rs                |   0
 .../tests/assets/ok/surrogate.fail            |   0
 .../tests/assets/ok/undefine.fail             |   0
 .../tests/assets/ok/unicode.d.ts              |   0
 .../tests/assets/ok/unicode.did               |   0
 .../tests/assets/ok/unicode.js                |   0
 .../tests/assets/ok/unicode.rs                |   0
 .../tests/assets/oneway.did                   |   0
 .../tests/assets/recursion.did                |   0
 .../tests/assets/recursive_class.did          |   0
 .../tests/assets/service.did                  |   0
 .../tests/assets/surrogate.did                |   0
 .../tests/assets/undefine.did                 |   0
 .../tests/assets/unicode.did                  |   0
 .../tests/parse_type.rs                       |  15 +-
 .../tests/parse_value.rs                      |  27 +-
 .../tests/test_suite.rs                       |   4 +-
 rust/{candid => candid_parser}/tests/value.rs |  13 +-
 rust/ic_principal/Cargo.toml                  |  44 ++
 rust/ic_principal/LICENSE                     |   1 +
 rust/ic_principal/README.md                   |   5 +
 rust/ic_principal/src/lib.rs                  | 388 ++++++++++++
 .../tests/principal.rs                        |   5 +-
 tools/didc/Cargo.toml                         |   2 +-
 tools/didc/src/main.rs                        |  72 ++-
 182 files changed, 2101 insertions(+), 2123 deletions(-)
 delete mode 100644 rust/candid/src/bindings/mod.rs
 delete mode 100644 rust/candid/src/parser/grammar.rs
 delete mode 100644 rust/candid/src/parser/mod.rs
 rename rust/candid/src/{bindings => pretty}/candid.rs (92%)
 create mode 100644 rust/candid/src/pretty/mod.rs
 rename rust/candid/src/{pretty.rs => pretty/utils.rs} (90%)
 create mode 100644 rust/candid/src/types/leb128.rs
 create mode 100644 rust/candid_parser/Cargo.toml
 create mode 120000 rust/candid_parser/LICENSE
 rename rust/{candid => candid_parser}/build.rs (62%)
 rename rust/{candid => candid_parser}/src/bindings/analysis.rs (98%)
 rename rust/{candid => candid_parser}/src/bindings/javascript.rs (93%)
 create mode 100644 rust/candid_parser/src/bindings/mod.rs
 rename rust/{candid => candid_parser}/src/bindings/motoko.rs (92%)
 rename rust/{candid => candid_parser}/src/bindings/rust.rs (95%)
 rename rust/{candid => candid_parser}/src/bindings/typescript.rs (93%)
 rename rust/{candid/src/parser => candid_parser/src}/configs.rs (99%)
 create mode 100644 rust/candid_parser/src/error.rs
 rename rust/{candid/src/parser => candid_parser/src}/grammar.lalrpop (96%)
 create mode 100644 rust/candid_parser/src/grammar.rs
 create mode 100644 rust/candid_parser/src/lib.rs
 rename rust/{candid/src/parser => candid_parser/src}/random.rs (82%)
 rename rust/{candid/src/parser => candid_parser/src}/test.rs (95%)
 rename rust/{candid/src/parser => candid_parser/src}/token.rs (100%)
 rename rust/{candid/src/parser => candid_parser/src}/types.rs (98%)
 rename rust/{candid/src/parser => candid_parser/src}/typing.rs (95%)
 create mode 100644 rust/candid_parser/src/utils.rs
 rename rust/{candid => candid_parser}/tests/assets/actor.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/bad_comment.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/bad_import.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/class.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/codegen/basic/invalid_id.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/codegen/basic/invalid_id.rs (100%)
 rename rust/{candid => candid_parser}/tests/assets/codegen/basic/prim_types.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/codegen/basic/prim_types.rs (100%)
 rename rust/{candid => candid_parser}/tests/assets/codegen/basic/recursive.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/codegen/basic/recursive.rs (100%)
 rename rust/{candid => candid_parser}/tests/assets/codegen/examples/linkedup.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/codegen/examples/linkedup.rs (100%)
 rename rust/{candid => candid_parser}/tests/assets/collision_fields.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/collision_fields2.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/comment.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/cyclic.did (100%)
 create mode 100644 rust/candid_parser/tests/assets/empty.did
 rename rust/{candid => candid_parser}/tests/assets/escape.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/example.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/fieldnat.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/import/a.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/import/b/b.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/invalid_cyclic.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/keyword.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/management.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/not_func.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/not_serv.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/actor.d.ts (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/actor.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/actor.js (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/actor.mo (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/actor.rs (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/bad_comment.fail (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/bad_import.fail (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/class.d.ts (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/class.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/class.js (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/class.mo (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/class.rs (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/collision_fields.fail (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/collision_fields2.fail (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/comment.d.ts (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/comment.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/comment.js (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/comment.mo (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/comment.rs (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/cyclic.d.ts (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/cyclic.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/cyclic.js (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/cyclic.mo (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/cyclic.rs (100%)
 create mode 100644 rust/candid_parser/tests/assets/ok/empty.d.ts
 create mode 100644 rust/candid_parser/tests/assets/ok/empty.did
 create mode 100644 rust/candid_parser/tests/assets/ok/empty.js
 create mode 100644 rust/candid_parser/tests/assets/ok/empty.mo
 create mode 100644 rust/candid_parser/tests/assets/ok/empty.rs
 rename rust/{candid => candid_parser}/tests/assets/ok/escape.d.ts (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/escape.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/escape.js (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/escape.rs (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/example.d.ts (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/example.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/example.js (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/example.mo (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/example.rs (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/fieldnat.d.ts (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/fieldnat.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/fieldnat.js (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/fieldnat.mo (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/fieldnat.rs (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/invalid_cyclic.fail (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/keyword.d.ts (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/keyword.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/keyword.js (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/keyword.mo (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/keyword.rs (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/management.d.ts (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/management.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/management.js (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/management.mo (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/management.rs (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/not_func.fail (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/not_serv.fail (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/oneway.fail (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/recursion.d.ts (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/recursion.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/recursion.js (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/recursion.mo (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/recursion.rs (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/recursive_class.d.ts (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/recursive_class.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/recursive_class.js (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/recursive_class.mo (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/recursive_class.rs (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/service.d.ts (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/service.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/service.js (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/service.mo (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/service.rs (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/surrogate.fail (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/undefine.fail (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/unicode.d.ts (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/unicode.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/unicode.js (100%)
 rename rust/{candid => candid_parser}/tests/assets/ok/unicode.rs (100%)
 rename rust/{candid => candid_parser}/tests/assets/oneway.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/recursion.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/recursive_class.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/service.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/surrogate.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/undefine.did (100%)
 rename rust/{candid => candid_parser}/tests/assets/unicode.did (100%)
 rename rust/{candid => candid_parser}/tests/parse_type.rs (88%)
 rename rust/{candid => candid_parser}/tests/parse_value.rs (93%)
 rename rust/{candid => candid_parser}/tests/test_suite.rs (85%)
 rename rust/{candid => candid_parser}/tests/value.rs (93%)
 create mode 100644 rust/ic_principal/Cargo.toml
 create mode 120000 rust/ic_principal/LICENSE
 create mode 100644 rust/ic_principal/README.md
 create mode 100644 rust/ic_principal/src/lib.rs
 rename rust/{candid => ic_principal}/tests/principal.rs (98%)

diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index ea2101ec..c9b3bb0e 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -2,7 +2,7 @@ name: Rust Bench
 on:
   pull_request:
     paths:
-    - 'rust/**'
+    - 'rust/candid/**'
 jobs:
   runBenchMark:
     name: run benchmark
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index b50037a8..9f21e218 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -26,9 +26,13 @@ jobs:
           target
         key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
     - name: Build
-      run: cargo build
+      run: |
+        cargo build
     - name: Run tests
-      run: cargo test --features all
+      run: |
+        cargo test --no-default-features
+        cargo test
+        cargo test --features all
     - name: fmt
       run: cargo fmt -v -- --check
     - name: lint
diff --git a/Cargo.lock b/Cargo.lock
index 899e13ab..5ca030d7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -35,9 +35,9 @@ dependencies = [
 
 [[package]]
 name = "aho-corasick"
-version = "1.1.1"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea5d730647d4fadd988536d06fecce94b7b4f2a7efdae548f1cf4b63205518ab"
+checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
 dependencies = [
  "memchr",
 ]
@@ -59,9 +59,9 @@ dependencies = [
 
 [[package]]
 name = "anstream"
-version = "0.5.0"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f58811cfac344940f1a400b6e6231ce35171f614f26439e80f8c1465c5cc0c"
+checksum = "2ab91ebe16eb252986481c5b62f6098f3b698a45e34b5b98200cf20dd2484a44"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -73,15 +73,15 @@ dependencies = [
 
 [[package]]
 name = "anstyle"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b84bf0a05bbb2a83e5eb6fa36bb6e87baa08193c35ff52bbf6b38d8af2890e46"
+checksum = "7079075b41f533b8c61d2a4d073c4676e1f8b249ff94a393b0595db304e0dd87"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "938874ff5980b03a87c5524b3ae5b59cf99b1d6bc836848df7bc5ada9643c333"
+checksum = "317b9a89c1868f5ea6ff1d9539a69f45dffc21ce321ac1fd1160dfa48c8e2140"
 dependencies = [
  "utf8parse",
 ]
@@ -97,9 +97,9 @@ dependencies = [
 
 [[package]]
 name = "anstyle-wincon"
-version = "2.1.0"
+version = "3.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58f54d10c6dfa51283a066ceab3ec1ab78d13fae00aa49243a45e4571fb79dfd"
+checksum = "f0699d10d2f4d628a98ee7b57b289abbc98ff3bad977cb3152709d4bf2330628"
 dependencies = [
  "anstyle",
  "windows-sys 0.48.0",
@@ -113,9 +113,9 @@ checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6"
 
 [[package]]
 name = "arbitrary"
-version = "1.3.0"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2d098ff73c1ca148721f37baad5ea6a465a13f9573aba8641fbbbae8164a54e"
+checksum = "a2e1373abdaa212b704512ec2bd8b26bd0b7d5c3f70117411a5d9a451383c859"
 
 [[package]]
 name = "arrayvec"
@@ -182,7 +182,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d9672209df1714ee804b1f4d4f68c8eb2a90b1f7a07acf472f88ce198ef1fed"
 dependencies = [
  "either",
- "proc-macro2 1.0.67",
+ "proc-macro2 1.0.69",
  "quote 1.0.33",
  "syn 1.0.109",
 ]
@@ -210,9 +210,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.4.0"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4682ae6287fcf752ecaabbfcc7b6f9b72aa33933dc23a554d853aea8eea8635"
+checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07"
 
 [[package]]
 name = "block-buffer"
@@ -251,59 +251,69 @@ checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec"
 
 [[package]]
 name = "byteorder"
-version = "1.4.3"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "candid"
-version = "0.9.11"
+version = "0.10.0"
 dependencies = [
  "anyhow",
- "arbitrary",
  "bincode",
  "binread",
  "byteorder",
  "candid_derive",
- "codespan-reporting",
- "convert_case",
- "crc32fast",
  "criterion",
- "data-encoding",
- "fake",
- "goldenfile",
  "hex",
- "impls",
- "lalrpop",
- "lalrpop-util",
+ "ic_principal",
  "leb128",
- "logos",
  "num-bigint",
  "num-traits",
- "num_enum",
  "paste",
  "pretty 0.12.3",
  "rand",
  "serde",
  "serde_bytes",
  "serde_cbor",
- "serde_dhall",
  "serde_json",
- "serde_test",
- "sha2 0.10.8",
  "stacker",
- "test-generator",
  "thiserror",
 ]
 
 [[package]]
 name = "candid_derive"
-version = "0.6.4"
+version = "0.6.5"
 dependencies = [
  "lazy_static",
- "proc-macro2 1.0.67",
+ "proc-macro2 1.0.69",
  "quote 1.0.33",
- "syn 2.0.37",
+ "syn 2.0.38",
+]
+
+[[package]]
+name = "candid_parser"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "arbitrary",
+ "candid",
+ "codespan-reporting",
+ "convert_case",
+ "fake",
+ "goldenfile",
+ "hex",
+ "lalrpop",
+ "lalrpop-util",
+ "logos",
+ "num-bigint",
+ "num-traits",
+ "pretty 0.12.3",
+ "rand",
+ "serde",
+ "serde_dhall",
+ "test-generator",
+ "thiserror",
 ]
 
 [[package]]
@@ -368,9 +378,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.4.5"
+version = "4.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "824956d0dca8334758a5b7f7e50518d66ea319330cbceedcf76905c2f6ab30e3"
+checksum = "ac495e00dcec98c83465d5ad66c5c4fabd652fd6686e7c6269b117e729a6f17b"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -378,26 +388,26 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.4.5"
+version = "4.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "122ec64120a49b4563ccaedcbea7818d069ed8e9aa6d829b82d8a4128936b2ab"
+checksum = "c77ed9a32a62e6ca27175d00d29d05ca32e396ea1eb5fb01d8256b669cec7663"
 dependencies = [
  "anstream",
  "anstyle",
- "clap_lex 0.5.1",
+ "clap_lex 0.6.0",
  "strsim",
 ]
 
 [[package]]
 name = "clap_derive"
-version = "4.4.2"
+version = "4.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0862016ff20d69b84ef8247369fabf5c008a7417002411897d40ee1f4532b873"
+checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442"
 dependencies = [
  "heck",
- "proc-macro2 1.0.67",
+ "proc-macro2 1.0.69",
  "quote 1.0.33",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -411,9 +421,9 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
-version = "0.5.1"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd7cc57abe963c6d3b9d8be5b06ba7c8957a930305ca90304f24ef040aa6f961"
+checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1"
 
 [[package]]
 name = "codespan-reporting"
@@ -454,9 +464,9 @@ dependencies = [
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.9"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a17b76ff3a4162b0b27f354a0c87015ddad39d35f9c0c36607a3bdd175dde1f1"
+checksum = "3fbc60abd742b35f2492f808e1abbb83d45f72db402e14c55057edc9c7b1e9e4"
 dependencies = [
  "libc",
 ]
@@ -561,6 +571,12 @@ version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2e66c9d817f1720209181c316d28635c050fa304f9c79e47a520882661b7308"
 
+[[package]]
+name = "deunicode"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a1abaf4d861455be59f64fd2b55606cb151fce304ede7165f410243ce96bde6"
+
 [[package]]
 name = "dhall"
 version = "0.11.1"
@@ -592,7 +608,7 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df7c81d16870879ef530b07cef32bc6088f98937ab4168106cc8e382a05146bf"
 dependencies = [
- "proc-macro2 1.0.67",
+ "proc-macro2 1.0.69",
  "quote 1.0.33",
  "syn 1.0.109",
 ]
@@ -602,8 +618,8 @@ name = "didc"
 version = "0.3.5"
 dependencies = [
  "anyhow",
- "candid",
- "clap 4.4.5",
+ "candid_parser",
+ "clap 4.4.7",
  "hex",
  "pretty-hex",
  "rand",
@@ -699,33 +715,22 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
 [[package]]
 name = "errno"
-version = "0.3.3"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "136526188508e25c6fef639d7927dfb3e0e3084488bf202267829cf7fc23dbdd"
+checksum = "ac3e13f66a2f95e32a39eaa81f6b95d42878ca0e1db0c7543723dfe12557e860"
 dependencies = [
- "errno-dragonfly",
  "libc",
  "windows-sys 0.48.0",
 ]
 
-[[package]]
-name = "errno-dragonfly"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
-dependencies = [
- "cc",
- "libc",
-]
-
 [[package]]
 name = "fake"
-version = "2.8.0"
+version = "2.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9af7b0c58ac9d03169e27f080616ce9f64004edca3d2ef4147a811c21b23b319"
+checksum = "26221445034074d46b276e13eb97a265ebdb8ed8da705c4dddd3dd20b66b45d2"
 dependencies = [
+ "deunicode",
  "rand",
- "unidecode",
 ]
 
 [[package]]
@@ -806,9 +811,9 @@ checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 
 [[package]]
 name = "hashbrown"
-version = "0.14.0"
+version = "0.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c6201b9ff9fd90a5a3bac2e56a830d0caa509576f0e503818ee82c181b3437a"
+checksum = "f93e7192158dbcda357bdec5fb5788eebf8bbac027f3f33e719d29135ae84156"
 
 [[package]]
 name = "heck"
@@ -846,6 +851,24 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
+[[package]]
+name = "ic_principal"
+version = "0.1.0"
+dependencies = [
+ "arbitrary",
+ "crc32fast",
+ "data-encoding",
+ "hex",
+ "impls",
+ "serde",
+ "serde_bytes",
+ "serde_cbor",
+ "serde_json",
+ "serde_test",
+ "sha2 0.10.8",
+ "thiserror",
+]
+
 [[package]]
 name = "idna"
 version = "0.4.0"
@@ -874,12 +897,12 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.0.1"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad227c3af19d4914570ad36d30409928b75967c298feb9ea1969db3a610bb14e"
+checksum = "8adf3ddd720272c6ea8bf59463c04e0f93d0bbf7c5439b691bca2987e0270897"
 dependencies = [
  "equivalent",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.2",
 ]
 
 [[package]]
@@ -972,9 +995,9 @@ checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
 
 [[package]]
 name = "libc"
-version = "0.2.148"
+version = "0.2.149"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cdc71e17332e86d2e1d38c1f99edcb6288ee11b815fb1a4b049eaa2114d369b"
+checksum = "a08173bc88b7955d1b3145aa561539096c421ac8debde8cbc3612ec635fee29b"
 
 [[package]]
 name = "linux-raw-sys"
@@ -984,9 +1007,9 @@ checksum = "da2479e8c062e40bf0066ffa0bc823de0a9368974af99c9f6df941d2c231e03f"
 
 [[package]]
 name = "lock_api"
-version = "0.4.10"
+version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1cc9717a20b1bb222f333e6a92fd32f7d8a18ddc5a3191a11af45dcbf4dcd16"
+checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45"
 dependencies = [
  "autocfg",
  "scopeguard",
@@ -1015,10 +1038,10 @@ checksum = "dc487311295e0002e452025d6b580b77bb17286de87b57138f3b5db711cded68"
 dependencies = [
  "beef",
  "fnv",
- "proc-macro2 1.0.67",
+ "proc-macro2 1.0.69",
  "quote 1.0.33",
  "regex-syntax 0.6.29",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -1032,9 +1055,9 @@ dependencies = [
 
 [[package]]
 name = "memchr"
-version = "2.6.3"
+version = "2.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f232d6ef707e1956a43342693d2a31e72989554d58299d7a88738cc95b0d35c"
+checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167"
 
 [[package]]
 name = "memoffset"
@@ -1091,34 +1114,13 @@ dependencies = [
 
 [[package]]
 name = "num-traits"
-version = "0.2.16"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f30b0abd723be7e2ffca1272140fac1a2f084c77ec3e123c192b66af1ee9e6c2"
+checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c"
 dependencies = [
  "autocfg",
 ]
 
-[[package]]
-name = "num_enum"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a015b430d3c108a207fd776d2e2196aaf8b1cf8cf93253e3a097ff3085076a1"
-dependencies = [
- "num_enum_derive",
-]
-
-[[package]]
-name = "num_enum_derive"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96667db765a921f7b295ffee8b60472b686a51d4f21c2ee4ffdb94c7013b65a6"
-dependencies = [
- "proc-macro-crate",
- "proc-macro2 1.0.67",
- "quote 1.0.33",
- "syn 2.0.37",
-]
-
 [[package]]
 name = "once_cell"
 version = "1.18.0"
@@ -1139,9 +1141,9 @@ checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
 
 [[package]]
 name = "os_str_bytes"
-version = "6.5.1"
+version = "6.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d5d9eb14b174ee9aa2ef96dc2b94637a2d4b6e7cb873c7e171f0c20c6cf3eac"
+checksum = "e2355d85b9a3786f481747ced0e0ff2ba35213a1f9bd406ed906554d7af805a1"
 
 [[package]]
 name = "parking_lot"
@@ -1155,13 +1157,13 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.8"
+version = "0.9.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93f00c865fe7cabf650081affecd3871070f26767e7b2070a3ffae14c654b447"
+checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e"
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall 0.3.5",
+ "redox_syscall 0.4.1",
  "smallvec",
  "windows-targets 0.48.5",
 ]
@@ -1180,9 +1182,9 @@ checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94"
 
 [[package]]
 name = "pest"
-version = "2.7.4"
+version = "2.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c022f1e7b65d6a24c0dbbd5fb344c66881bc01f3e5ae74a1c8100f2f985d98a4"
+checksum = "ae9cee2a55a544be8b89dc6848072af97a20f2422603c10865be2a42b580fff5"
 dependencies = [
  "memchr",
  "thiserror",
@@ -1206,16 +1208,16 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9d8630a7a899cb344ec1c16ba0a6b24240029af34bdc0a21f84e411d7f793f29"
 dependencies = [
- "proc-macro2 1.0.67",
+ "proc-macro2 1.0.69",
  "quote 1.0.33",
  "syn 1.0.109",
 ]
 
 [[package]]
 name = "pest_derive"
-version = "2.7.4"
+version = "2.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35513f630d46400a977c4cb58f78e1bfbe01434316e60c37d27b9ad6139c66d8"
+checksum = "81d78524685f5ef2a3b3bd1cafbc9fcabb036253d9b1463e726a91cd16e2dfc2"
 dependencies = [
  "pest",
  "pest_generator",
@@ -1223,22 +1225,22 @@ dependencies = [
 
 [[package]]
 name = "pest_generator"
-version = "2.7.4"
+version = "2.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc9fc1b9e7057baba189b5c626e2d6f40681ae5b6eb064dc7c7834101ec8123a"
+checksum = "68bd1206e71118b5356dae5ddc61c8b11e28b09ef6a31acbd15ea48a28e0c227"
 dependencies = [
  "pest",
  "pest_meta",
- "proc-macro2 1.0.67",
+ "proc-macro2 1.0.69",
  "quote 1.0.33",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
 name = "pest_meta"
-version = "2.7.4"
+version = "2.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1df74e9e7ec4053ceb980e7c0c8bd3594e977fde1af91daba9c928e8e8c6708d"
+checksum = "7c747191d4ad9e4a4ab9c8798f1e82a39affe7ef9648390b7e5548d18e099de6"
 dependencies = [
  "once_cell",
  "pest",
@@ -1252,7 +1254,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1d3afd2628e69da2be385eb6f2fd57c8ac7977ceeff6dc166ff1657b0e386a9"
 dependencies = [
  "fixedbitset",
- "indexmap 2.0.1",
+ "indexmap 2.0.2",
 ]
 
 [[package]]
@@ -1339,16 +1341,6 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bc5c99d529f0d30937f6f4b8a86d988047327bb88d04d2c4afc356de74722131"
 
-[[package]]
-name = "proc-macro-crate"
-version = "1.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919"
-dependencies = [
- "once_cell",
- "toml_edit",
-]
-
 [[package]]
 name = "proc-macro2"
 version = "0.4.30"
@@ -1360,9 +1352,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.67"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d433d9f1a3e8c1263d9456598b16fec66f4acc9a74dacffd35c7bb09b3a1328"
+checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da"
 dependencies = [
  "unicode-ident",
 ]
@@ -1391,7 +1383,7 @@ version = "1.0.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
 dependencies = [
- "proc-macro2 1.0.67",
+ "proc-macro2 1.0.69",
 ]
 
 [[package]]
@@ -1462,6 +1454,15 @@ dependencies = [
  "bitflags 1.3.2",
 ]
 
+[[package]]
+name = "redox_syscall"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
+dependencies = [
+ "bitflags 1.3.2",
+]
+
 [[package]]
 name = "redox_users"
 version = "0.4.3"
@@ -1475,14 +1476,14 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.9.5"
+version = "1.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "697061221ea1b4a94a624f67d0ae2bfe4e22b8a17b6a192afb11046542cc8c47"
+checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.3.8",
- "regex-syntax 0.7.5",
+ "regex-automata 0.4.3",
+ "regex-syntax 0.8.2",
 ]
 
 [[package]]
@@ -1493,13 +1494,13 @@ checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
 
 [[package]]
 name = "regex-automata"
-version = "0.3.8"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2f401f4955220693b56f8ec66ee9c78abffd8d1c4f23dc41a23839eb88f0795"
+checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax 0.7.5",
+ "regex-syntax 0.8.2",
 ]
 
 [[package]]
@@ -1514,13 +1515,19 @@ version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"
 
+[[package]]
+name = "regex-syntax"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
+
 [[package]]
 name = "rustix"
-version = "0.38.19"
+version = "0.38.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "745ecfa778e66b2b63c88a61cb36e0eea109e803b0b86bf9879fbc77c70e86ed"
+checksum = "67ce50cb2e16c2903e30d1cbccfd8387a74b9d4c938b6a4c5ec6cc7556f7a8a0"
 dependencies = [
- "bitflags 2.4.0",
+ "bitflags 2.4.1",
  "errno",
  "libc",
  "linux-raw-sys",
@@ -1556,9 +1563,9 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "serde"
-version = "1.0.188"
+version = "1.0.189"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf9e0fcba69a370eed61bcf2b728575f726b50b55cba78064753d708ddc7549e"
+checksum = "8e422a44e74ad4001bdc8eede9a4570ab52f71190e9c076d14369f38b9200537"
 dependencies = [
  "serde_derive",
 ]
@@ -1584,13 +1591,13 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.188"
+version = "1.0.189"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2"
+checksum = "1e48d1f918009ce3145511378cf68d613e3b3d9137d67272562080d68a2b32d5"
 dependencies = [
- "proc-macro2 1.0.67",
+ "proc-macro2 1.0.69",
  "quote 1.0.33",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -1652,9 +1659,9 @@ dependencies = [
 
 [[package]]
 name = "similar"
-version = "2.2.1"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "420acb44afdae038210c99e69aae24109f32f15500aa708e81d46c9f29d55fcf"
+checksum = "2aeaf503862c419d66959f5d7ca015337d864e9c49485d771b732e2a20453597"
 dependencies = [
  "bstr",
  "unicode-segmentation",
@@ -1737,18 +1744,18 @@ version = "1.0.109"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
 dependencies = [
- "proc-macro2 1.0.67",
+ "proc-macro2 1.0.69",
  "quote 1.0.33",
  "unicode-ident",
 ]
 
 [[package]]
 name = "syn"
-version = "2.0.37"
+version = "2.0.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7303ef2c05cd654186cb250d29049a24840ca25d2747c25c0381c8d9e2f582e8"
+checksum = "e96b79aaa137db8f61e26363a0c9b47d8b4ec75da28b7d1d614c2303e232408b"
 dependencies = [
- "proc-macro2 1.0.67",
+ "proc-macro2 1.0.69",
  "quote 1.0.33",
  "unicode-ident",
 ]
@@ -1806,22 +1813,22 @@ checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"
 
 [[package]]
 name = "thiserror"
-version = "1.0.49"
+version = "1.0.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1177e8c6d7ede7afde3585fd2513e611227efd6481bd78d2e82ba1ce16557ed4"
+checksum = "f9a7210f5c9a7156bb50aa36aed4c95afb51df0df00713949448cf9e97d382d2"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.49"
+version = "1.0.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10712f02019e9288794769fba95cd6847df9874d49d871d062172f9dd41bc4cc"
+checksum = "266b2e40bc00e5a6c09c3584011e08b06f123c00362c92b975ba9843aaaa14b8"
 dependencies = [
- "proc-macro2 1.0.67",
+ "proc-macro2 1.0.69",
  "quote 1.0.33",
- "syn 2.0.37",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -1858,23 +1865,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
-[[package]]
-name = "toml_datetime"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cda73e2f1397b1262d6dfdcef8aafae14d1de7748d66822d3bfeeb6d03e5e4b"
-
-[[package]]
-name = "toml_edit"
-version = "0.19.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
-dependencies = [
- "indexmap 2.0.1",
- "toml_datetime",
- "winnow",
-]
-
 [[package]]
 name = "typed-arena"
 version = "2.0.2"
@@ -1938,12 +1928,6 @@ version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
 
-[[package]]
-name = "unidecode"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "402bb19d8e03f1d1a7450e2bd613980869438e0666331be3e073089124aa1adc"
-
 [[package]]
 name = "url"
 version = "2.4.1"
@@ -2002,9 +1986,9 @@ dependencies = [
  "bumpalo",
  "log",
  "once_cell",
- "proc-macro2 1.0.67",
+ "proc-macro2 1.0.69",
  "quote 1.0.33",
- "syn 2.0.37",
+ "syn 2.0.38",
  "wasm-bindgen-shared",
 ]
 
@@ -2024,9 +2008,9 @@ version = "0.2.87"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b"
 dependencies = [
- "proc-macro2 1.0.67",
+ "proc-macro2 1.0.69",
  "quote 1.0.33",
- "syn 2.0.37",
+ "syn 2.0.38",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
@@ -2209,12 +2193,3 @@ name = "windows_x86_64_msvc"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
-
-[[package]]
-name = "winnow"
-version = "0.5.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c2e3184b9c4e92ad5167ca73039d0c42476302ab603e2fec4487511f38ccefc"
-dependencies = [
- "memchr",
-]
diff --git a/Cargo.toml b/Cargo.toml
index 352d28c5..45a462f2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,8 +1,20 @@
 [workspace]
 members = [
     "rust/candid",
+    "rust/candid_parser",
     "rust/candid_derive",
+    "rust/ic_principal",
     "tools/didc",
 ]
 resolver = "2"
 
+[workspace.dependencies]
+hex = "0.4.3"
+num-bigint = { version = "0.4", features = ["serde"] }
+num-traits = "0.2"
+pretty = "0.12"
+serde = { version = "1.0", features = ["derive"] }
+thiserror = "1.0"
+anyhow = "1.0"
+rand = "0.8"
+arbitrary = "1.3"
diff --git a/Changelog.md b/Changelog.md
index 51a20b77..83381c74 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -1,9 +1,41 @@
 
 # Changelog
 
-## Rust 0.9.9
+## Rust 0.10.0
+
+### Breaking changes
+
+* The original `candid` crate is split into three crates:
+  * `candid`: mainly for Candid data (de-)serialization.
+    + `candid::bindings::candid` moves to `candid::pretty::candid`. `candid::pretty` moves to `candid::pretty::utils`. These modules are only available under feature flag `printer` (enabled by default).
+    + `candid::{Int, Nat}` is only available under feature flag `bignum` (enabled by default). If this feature is not enabled, you can use `i128/u128` for `int/nat` type.
+    + Remove operator for `i32` and `Nat`.
+    + Add `IDLValue::Blob(Vec<u8>)` enum for efficient handling of blob value.
+    + `candid::types::number::pp_num_str` moves to `candid::utils::pp_num_str`.
+    + `candid::types::value` module is only availble under feature flag `value`.
+    + `mute_warning` feature flag is removed, use `candid::types::subtype_with_config` instead.
+  * `candid_parser`: used to be the `parser` and `bindings` module in `candid` crate.
+    + Remove `FromStr` trait for `IDLArgs` and `IDLValue`. Use `parse_idl_args` and `parse_idl_value` respectively instead.
+    + `TypeEnv.ast_to_type` becomes `candid_parser::typing::ast_to_type`.
+    + `bindings::rust::Config` uses builder pattern.
+    + `candid` is re-exported in `candid_parser::candid`.
+    + `candid::*` is re-exported in `candid_parser`.
+  * `ic_principal`: only for `Principal` and `PrincipalError`.
+
+### Non-breaking changes
+
+* Add `candid::types::subtype_with_config` to control the error reporting level of special opt rule.
+* Add `Type.is_blob(env)` method to check if a type is a blob type.
+* Fix TS binding for `variant {}`.
+
+## Rust 0.9.9 -- 0.9.11
 
 * Set different config values for `full_error_message` and `zero_sized_values` for Wasm and non-Wasm target.
+* Fix subtyping error message for empty type.
+* Remove name duplication check in `candid_method` to avoid errors on certain IDEs.
+* Improvements in Candid UI
+  + Add II button, thanks to @Web3NL.
+  + Support streaming download of profiling data.
 
 ## 2023-09-27
 
diff --git a/rust/candid/Cargo.toml b/rust/candid/Cargo.toml
index 9580da64..fa44a26a 100644
--- a/rust/candid/Cargo.toml
+++ b/rust/candid/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "candid"
-version = "0.9.11"
+version = "0.10.0"
 edition = "2021"
 authors = ["DFINITY Team"]
 description = "Candid is an interface description language (IDL) for interacting with canisters running on the Internet Computer."
@@ -9,57 +9,35 @@ documentation = "https://docs.rs/candid"
 repository = "https://github.com/dfinity/candid"
 license = "Apache-2.0"
 readme = "README.md"
-
-categories = ["encoding", "parsing", "wasm"]
-keywords = ["internet-computer", "idl", "candid", "dfinity", "parser"]
-include = ["src", "Cargo.toml", "build.rs", "LICENSE", "README.md"]
-build = "build.rs"
-
-[build-dependencies]
-lalrpop = { version = "0.20.0", optional = true }
+categories = ["encoding", "wasm"]
+keywords = ["internet-computer", "idl", "candid", "dfinity"]
+include = ["src", "Cargo.toml", "LICENSE", "README.md"]
 
 [dependencies]
-byteorder = "1.4.3"
-candid_derive = { path = "../candid_derive", version = "=0.6.4" }
-codespan-reporting = "0.11"
-crc32fast = "1.3.0"
-data-encoding = "2.4.0"
-hex = "0.4.2"
-leb128 = "0.2.4"
-num_enum = "0.6.1"
-num-bigint = { version = "0.4.2", features = ["serde"] }
-num-traits = "0.2.12"
-paste = "1.0.0"
-pretty = "0.12.0"
-serde = { version = "1.0.118", features = ["derive"] }
-serde_bytes = "0.11"
-sha2 = "0.10.1"
-thiserror = "1.0.20"
-anyhow = "1.0"
+candid_derive = { path = "../candid_derive", version = "=0.6.5" }
+ic_principal = { path = "../ic_principal", version = "0.1.0" }
 binread = { version = "2.1", features = ["debug_template"] }
+byteorder = "1.5.0"
+leb128 = "0.2.5"
+paste = "1.0"
+hex.workspace = true
+serde.workspace = true
+thiserror.workspace = true
+anyhow.workspace = true
 
-lalrpop-util = { version = "0.20.0", optional = true }
-logos = { version = "0.13", optional = true }
-convert_case = { version = "0.6", optional = true }
-
-arbitrary = { version = "1.0", optional = true }
-# Don't upgrade serde_dhall. It will introduce dependency with invalid license.
-serde_dhall = { version = "0.11", default-features = false, optional = true }
-fake = { version = "2.4", optional = true }
-rand = { version = "0.8", optional = true }
+serde_bytes = { version = "0.11", optional = true }
+pretty = { workspace = true, optional = true }
+num-bigint = { workspace = true, optional = true }
+num-traits = { workspace = true, optional = true }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 stacker = "0.1"
 
 [dev-dependencies]
-goldenfile = "1.1.0"
-test-generator = "0.3.0"
-rand = "0.8"
+rand.workspace = true
 criterion = "0.4"
 serde_cbor = "0.11.2"
 serde_json = "1.0.74"
-serde_test = "1.0.137"
-impls = "1"
 bincode = "1.3.3"
 
 [[bench]]
@@ -67,29 +45,25 @@ name = "benchmark"
 harness = false
 path = "benches/benchmark.rs"
 
+[features]
+bignum = ["dep:num-bigint", "dep:num-traits"]
+printer = ["dep:pretty"]
+value = ["bignum", "printer"]
+default = ["serde_bytes", "printer", "bignum"]
+all = ["default", "value", "ic_principal/arbitrary"]
+
 [[test]]
-name = "test_suite"
-path = "tests/test_suite.rs"
-required-features = ["parser"]
-[[test]]
-name = "value"
-path = "tests/value.rs"
-required-features = ["parser"]
+name = "types"
+path = "tests/types.rs"
+required-features = ["value"]
 [[test]]
-name = "parse_value"
-path = "tests/parse_value.rs"
-required-features = ["parser"]
+name = "serde"
+path = "tests/serde.rs"
+required-features = ["bignum"]
 [[test]]
-name = "parse_type"
-path = "tests/parse_type.rs"
-required-features = ["parser"]
-
-[features]
-configs = ["serde_dhall"]
-random = ["parser", "configs", "arbitrary", "fake", "rand"]
-parser = ["lalrpop", "lalrpop-util", "logos", "convert_case"]
-all = ["random"]
-mute_warnings = []
+name = "number"
+path = "tests/number.rs"
+required-features = ["bignum"]
 
 # docs.rs-specific configuration
 # To test locally: RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc --features all
diff --git a/rust/candid/benches/benchmark.rs b/rust/candid/benches/benchmark.rs
index 14deb618..6a66c519 100644
--- a/rust/candid/benches/benchmark.rs
+++ b/rust/candid/benches/benchmark.rs
@@ -92,8 +92,9 @@ fn bench_collections(c: &mut Criterion) {
         });
     }
     {
-        let map: BTreeMap<String, Nat> =
-            (0..65536).map(|i| (i.to_string(), Nat::from(i))).collect();
+        let map: BTreeMap<String, Nat> = (0u32..65536u32)
+            .map(|i| (i.to_string(), Nat::from(i)))
+            .collect();
         group.bench_function("vec (text, nat)", |b| {
             b.iter_batched(
                 || map.clone(),
diff --git a/rust/candid/fuzz/Cargo.lock b/rust/candid/fuzz/Cargo.lock
index a908c669..0ffc0331 100644
--- a/rust/candid/fuzz/Cargo.lock
+++ b/rust/candid/fuzz/Cargo.lock
@@ -2,15 +2,6 @@
 # It is not intended for manual editing.
 version = 3
 
-[[package]]
-name = "aho-corasick"
-version = "0.7.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc936419f96fa211c1b9166887b38e5e40b19958e5b895be7c1f93adec7071ac"
-dependencies = [
- "memchr",
-]
-
 [[package]]
 name = "anyhow"
 version = "1.0.68"
@@ -19,9 +10,9 @@ checksum = "2cb2f989d18dd141ab8ae82f64d1a8cdd37e0840f73a406896cf5e99502fab61"
 
 [[package]]
 name = "arbitrary"
-version = "1.2.3"
+version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e90af4de65aa7b293ef2d09daff88501eb254f58edde2e1ac02c82d873eadad"
+checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110"
 
 [[package]]
 name = "arrayvec"
@@ -29,38 +20,12 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
 
-[[package]]
-name = "ascii-canvas"
-version = "3.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8824ecca2e851cec16968d54a01dd372ef8f95b244fb84b84e70128be347c3c6"
-dependencies = [
- "term",
-]
-
-[[package]]
-name = "atty"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
-dependencies = [
- "hermit-abi",
- "libc",
- "winapi",
-]
-
 [[package]]
 name = "autocfg"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
-[[package]]
-name = "beef"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1"
-
 [[package]]
 name = "binread"
 version = "2.2.0"
@@ -81,30 +46,9 @@ dependencies = [
  "either",
  "proc-macro2",
  "quote",
- "syn",
-]
-
-[[package]]
-name = "bit-set"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
-dependencies = [
- "bit-vec",
+ "syn 1.0.107",
 ]
 
-[[package]]
-name = "bit-vec"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
-
-[[package]]
-name = "bitflags"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
 [[package]]
 name = "block-buffer"
 version = "0.10.3"
@@ -116,34 +60,28 @@ dependencies = [
 
 [[package]]
 name = "byteorder"
-version = "1.4.3"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "candid"
-version = "0.9.0-beta.2"
+version = "0.9.100"
 dependencies = [
  "anyhow",
  "binread",
  "byteorder",
  "candid_derive",
- "codespan-reporting",
- "crc32fast",
- "data-encoding",
  "hex",
- "lalrpop",
- "lalrpop-util",
+ "ic_principal",
  "leb128",
- "logos",
  "num-bigint",
  "num-traits",
- "num_enum",
  "paste",
  "pretty",
  "serde",
  "serde_bytes",
- "sha2",
+ "stacker",
  "thiserror",
 ]
 
@@ -159,12 +97,12 @@ dependencies = [
 
 [[package]]
 name = "candid_derive"
-version = "0.6.0"
+version = "0.6.5"
 dependencies = [
  "lazy_static",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.38",
 ]
 
 [[package]]
@@ -182,16 +120,6 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
-[[package]]
-name = "codespan-reporting"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
-dependencies = [
- "termcolor",
- "unicode-width",
-]
-
 [[package]]
 name = "cpufeatures"
 version = "0.2.5"
@@ -210,12 +138,6 @@ dependencies = [
  "cfg-if",
 ]
 
-[[package]]
-name = "crunchy"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
-
 [[package]]
 name = "crypto-common"
 version = "0.1.6"
@@ -232,12 +154,6 @@ version = "2.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "23d8666cb01533c39dde32bcbab8e227b4ed6679b2c925eba05feabea39508fb"
 
-[[package]]
-name = "diff"
-version = "0.1.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
-
 [[package]]
 name = "digest"
 version = "0.10.6"
@@ -248,54 +164,12 @@ dependencies = [
  "crypto-common",
 ]
 
-[[package]]
-name = "dirs-next"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"
-dependencies = [
- "cfg-if",
- "dirs-sys-next",
-]
-
-[[package]]
-name = "dirs-sys-next"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
-dependencies = [
- "libc",
- "redox_users",
- "winapi",
-]
-
 [[package]]
 name = "either"
 version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91"
 
-[[package]]
-name = "ena"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7402b94a93c24e742487327a7cd839dc9d36fec9de9fb25b09f2dae459f36c3"
-dependencies = [
- "log",
-]
-
-[[package]]
-name = "fixedbitset"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
-
-[[package]]
-name = "fnv"
-version = "1.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
-
 [[package]]
 name = "generic-array"
 version = "0.14.6"
@@ -306,32 +180,6 @@ dependencies = [
  "version_check",
 ]
 
-[[package]]
-name = "getrandom"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
-
-[[package]]
-name = "hermit-abi"
-version = "0.1.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "hex"
 version = "0.4.3"
@@ -339,22 +187,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
-name = "indexmap"
-version = "1.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
+name = "ic_principal"
+version = "0.1.0"
 dependencies = [
- "autocfg",
- "hashbrown",
-]
-
-[[package]]
-name = "itertools"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
-dependencies = [
- "either",
+ "arbitrary",
+ "crc32fast",
+ "data-encoding",
+ "hex",
+ "serde",
+ "serde_bytes",
+ "sha2",
+ "thiserror",
 ]
 
 [[package]]
@@ -366,38 +209,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "lalrpop"
-version = "0.19.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b30455341b0e18f276fa64540aff54deafb54c589de6aca68659c63dd2d5d823"
-dependencies = [
- "ascii-canvas",
- "atty",
- "bit-set",
- "diff",
- "ena",
- "itertools",
- "lalrpop-util",
- "petgraph",
- "pico-args",
- "regex",
- "regex-syntax",
- "string_cache",
- "term",
- "tiny-keccak",
- "unicode-xid",
-]
-
-[[package]]
-name = "lalrpop-util"
-version = "0.19.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcf796c978e9b4d983414f4caedc9273aa33ee214c5b887bd55fde84c85d2dc4"
-dependencies = [
- "regex",
-]
-
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -412,9 +223,9 @@ checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
 
 [[package]]
 name = "libc"
-version = "0.2.139"
+version = "0.2.149"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79"
+checksum = "a08173bc88b7955d1b3145aa561539096c421ac8debde8cbc3612ec635fee29b"
 
 [[package]]
 name = "libfuzzer-sys"
@@ -427,69 +238,6 @@ dependencies = [
  "once_cell",
 ]
 
-[[package]]
-name = "lock_api"
-version = "0.4.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "435011366fe56583b16cf956f9df0095b405b82d76425bc8981c0e22e60ec4df"
-dependencies = [
- "autocfg",
- "scopeguard",
-]
-
-[[package]]
-name = "log"
-version = "0.4.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
-dependencies = [
- "cfg-if",
-]
-
-[[package]]
-name = "logos"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf8b031682c67a8e3d5446840f9573eb7fe26efe7ec8d195c9ac4c0647c502f1"
-dependencies = [
- "logos-derive",
-]
-
-[[package]]
-name = "logos-derive"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1d849148dbaf9661a6151d1ca82b13bb4c4c128146a88d05253b38d4e2f496c"
-dependencies = [
- "beef",
- "fnv",
- "proc-macro2",
- "quote",
- "regex-syntax",
- "syn",
-]
-
-[[package]]
-name = "memchr"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
-
-[[package]]
-name = "new_debug_unreachable"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54"
-
-[[package]]
-name = "nom8"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae01545c9c7fc4486ab7debaf2aad7003ac19431791868fb2e8066df97fad2f8"
-dependencies = [
- "memchr",
-]
-
 [[package]]
 name = "num-bigint"
 version = "0.4.3"
@@ -521,180 +269,62 @@ dependencies = [
  "autocfg",
 ]
 
-[[package]]
-name = "num_enum"
-version = "0.5.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d829733185c1ca374f17e52b762f24f535ec625d2cc1f070e34c8a9068f341b"
-dependencies = [
- "num_enum_derive",
-]
-
-[[package]]
-name = "num_enum_derive"
-version = "0.5.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2be1598bf1c313dcdd12092e3f1920f463462525a21b7b4e11b4168353d0123e"
-dependencies = [
- "proc-macro-crate",
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "once_cell"
 version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f61fba1741ea2b3d6a1e3178721804bb716a68a6aeba1149b5d52e3d464ea66"
 
-[[package]]
-name = "parking_lot"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
-dependencies = [
- "lock_api",
- "parking_lot_core",
-]
-
-[[package]]
-name = "parking_lot_core"
-version = "0.9.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba1ef8814b5c993410bb3adfad7a5ed269563e4a2f90c41f5d85be7fb47133bf"
-dependencies = [
- "cfg-if",
- "libc",
- "redox_syscall",
- "smallvec",
- "windows-sys",
-]
-
 [[package]]
 name = "paste"
 version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d01a5bd0424d00070b0098dd17ebca6f961a959dead1dbcbbbc1d1cd8d3deeba"
 
-[[package]]
-name = "petgraph"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5014253a1331579ce62aa67443b4a658c5e7dd03d4bc6d302b94474888143"
-dependencies = [
- "fixedbitset",
- "indexmap",
-]
-
-[[package]]
-name = "phf_shared"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096"
-dependencies = [
- "siphasher",
-]
-
-[[package]]
-name = "pico-args"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db8bcd96cb740d03149cbad5518db9fd87126a10ab519c011893b1754134c468"
-
-[[package]]
-name = "precomputed-hash"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
-
 [[package]]
 name = "pretty"
-version = "0.10.0"
+version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad9940b913ee56ddd94aec2d3cd179dd47068236f42a1a6415ccf9d880ce2a61"
+checksum = "b55c4d17d994b637e2f4daf6e5dc5d660d209d5642377d675d7a1c3ab69fa579"
 dependencies = [
  "arrayvec",
  "typed-arena",
-]
-
-[[package]]
-name = "proc-macro-crate"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66618389e4ec1c7afe67d51a9bf34ff9236480f8d51e7489b7d5ab0303c13f34"
-dependencies = [
- "once_cell",
- "toml_edit",
+ "unicode-width",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.50"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ef7d57beacfaf2d8aee5937dab7b7f28de3cb8b1828479bb5de2a7106f2bae2"
+checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
-name = "quote"
-version = "1.0.23"
+name = "psm"
+version = "0.1.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8856d8364d252a14d474036ea1358d63c9e6965c8e5c1885c18f73d70bff9c7b"
+checksum = "5787f7cda34e3033a72192c018bc5883100330f362ef279a8cbccfce8bb4e874"
 dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
-dependencies = [
- "bitflags",
-]
-
-[[package]]
-name = "redox_users"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
-dependencies = [
- "getrandom",
- "redox_syscall",
- "thiserror",
+ "cc",
 ]
 
 [[package]]
-name = "regex"
-version = "1.7.1"
+name = "quote"
+version = "1.0.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48aaa5748ba571fb95cd2c85c09f629215d3a6ece942baa100950af03a34f733"
+checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
 dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
+ "proc-macro2",
 ]
 
-[[package]]
-name = "regex-syntax"
-version = "0.6.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
-
 [[package]]
 name = "rustversion"
 version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5583e89e108996506031660fe09baa5011b9dd0341b89029313006d1fb508d70"
 
-[[package]]
-name = "scopeguard"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
-
 [[package]]
 name = "serde"
 version = "1.0.152"
@@ -721,7 +351,7 @@ checksum = "af487d118eecd09402d70a5d72551860e788df87b464af30e5ea6a38c75c541e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 1.0.107",
 ]
 
 [[package]]
@@ -736,28 +366,16 @@ dependencies = [
 ]
 
 [[package]]
-name = "siphasher"
-version = "0.3.10"
+name = "stacker"
+version = "0.1.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bd3e3206899af3f8b12af284fafc038cc1dc2b41d1b89dd17297221c5d225de"
-
-[[package]]
-name = "smallvec"
-version = "1.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
-
-[[package]]
-name = "string_cache"
-version = "0.8.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "213494b7a2b503146286049378ce02b482200519accc31872ee8be91fa820a08"
+checksum = "c886bd4480155fd3ef527d45e9ac8dd7118a898a46530b7b94c3e21866259fce"
 dependencies = [
- "new_debug_unreachable",
- "once_cell",
- "parking_lot",
- "phf_shared",
- "precomputed-hash",
+ "cc",
+ "cfg-if",
+ "libc",
+ "psm",
+ "winapi",
 ]
 
 [[package]]
@@ -772,23 +390,14 @@ dependencies = [
 ]
 
 [[package]]
-name = "term"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f"
-dependencies = [
- "dirs-next",
- "rustversion",
- "winapi",
-]
-
-[[package]]
-name = "termcolor"
-version = "1.2.0"
+name = "syn"
+version = "2.0.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6"
+checksum = "e96b79aaa137db8f61e26363a0c9b47d8b4ec75da28b7d1d614c2303e232408b"
 dependencies = [
- "winapi-util",
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
 ]
 
 [[package]]
@@ -808,33 +417,7 @@ checksum = "1fb327af4685e4d03fa8cbcf1716380da910eeb2bb8be417e7f9fd3fb164f36f"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
-]
-
-[[package]]
-name = "tiny-keccak"
-version = "2.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
-dependencies = [
- "crunchy",
-]
-
-[[package]]
-name = "toml_datetime"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4553f467ac8e3d374bc9a177a26801e5d0f9b211aa1673fb137a403afd1c9cf5"
-
-[[package]]
-name = "toml_edit"
-version = "0.18.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56c59d8dd7d0dcbc6428bf7aa2f0e823e26e43b3c9aca15bbc9475d23e5fa12b"
-dependencies = [
- "indexmap",
- "nom8",
- "toml_datetime",
+ "syn 1.0.107",
 ]
 
 [[package]]
@@ -861,24 +444,12 @@ version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
 
-[[package]]
-name = "unicode-xid"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
-
 [[package]]
 name = "version_check"
 version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
-
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -895,74 +466,8 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
-[[package]]
-name = "winapi-util"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
-dependencies = [
- "winapi",
-]
-
 [[package]]
 name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-
-[[package]]
-name = "windows-sys"
-version = "0.42.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
-dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
-]
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c9864e83243fdec7fc9c5444389dcbbfd258f745e7853198f365e3c4968a608"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c8b1b673ffc16c47a9ff48570a9d85e25d265735c503681332589af6253c6c7"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de3887528ad530ba7bdbb1faa8275ec7a1155a45ffa57c37993960277145d640"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf4d1122317eddd6ff351aa852118a2418ad4214e6613a50e0191f7004372605"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1040f221285e17ebccbc2591ffdc2d44ee1f9186324dd3e84e99ac68d699c45"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "628bfdf232daa22b0d64fdb62b09fcc36bb01f05a3939e20ab73aaf9470d0463"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "447660ad36a13288b1db4d4248e857b510e8c3a225c822ba4fb748c0aafecffd"
diff --git a/rust/candid/fuzz/Cargo.toml b/rust/candid/fuzz/Cargo.toml
index 2c011dab..47e0514e 100644
--- a/rust/candid/fuzz/Cargo.toml
+++ b/rust/candid/fuzz/Cargo.toml
@@ -15,7 +15,7 @@ serde = "1.0.115"
 
 [dependencies.candid]
 path = ".."
-features = ["parser"]
+features = ["all"]
 
 # Prevent this from interfering with workspaces
 [workspace]
diff --git a/rust/candid/fuzz/fuzz_targets/type_decoder.rs b/rust/candid/fuzz/fuzz_targets/type_decoder.rs
index b6e4a609..201c03e7 100644
--- a/rust/candid/fuzz/fuzz_targets/type_decoder.rs
+++ b/rust/candid/fuzz/fuzz_targets/type_decoder.rs
@@ -11,10 +11,10 @@ pub struct Token {
     pub sha256: Option<ByteBuf>,
 }
 
-define_function!(pub callback : (&u8) -> (Nat));
+define_function!(pub Callback : (&u8) -> (Nat));
 #[derive(CandidType, Deserialize)]
 pub struct CallbackStrategy {
-    pub callback: callback,
+    pub callback: Callback,
     pub token: Token,
 }
 
diff --git a/rust/candid/src/binary_parser.rs b/rust/candid/src/binary_parser.rs
index 74875313..03a7b6e2 100644
--- a/rust/candid/src/binary_parser.rs
+++ b/rust/candid/src/binary_parser.rs
@@ -5,14 +5,14 @@ use binread::io::{Read, Seek};
 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> {
+fn read_leb<R: Read + Seek>(reader: &mut R, ro: &ReadOptions, (): ()) -> BinResult<u64> {
     let pos = reader.stream_position()?;
     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> {
+fn read_sleb<R: Read + Seek>(reader: &mut R, ro: &ReadOptions, (): ()) -> BinResult<i64> {
     let pos = reader.stream_position()?;
     leb128::read::signed(reader).map_err(|_| BError::Custom {
         pos,
@@ -178,7 +178,7 @@ impl ConsType {
             ConsType::Record(fs) | ConsType::Variant(fs) => {
                 let mut res = Vec::new();
                 let mut prev = None;
-                for f in fs.inner.iter() {
+                for f in &fs.inner {
                     if let Some(prev) = prev {
                         if prev >= f.id {
                             return Err(anyhow!("field id {} collision or not sorted", f.id));
@@ -200,10 +200,10 @@ impl ConsType {
             ConsType::Func(f) => {
                 let mut args = Vec::new();
                 let mut rets = Vec::new();
-                for arg in f.args.iter() {
+                for arg in &f.args {
                     args.push(arg.to_type(len)?);
                 }
-                for ret in f.rets.iter() {
+                for ret in &f.rets {
                     rets.push(ret.to_type(len)?);
                 }
                 TypeInner::Func(Function {
@@ -215,7 +215,7 @@ impl ConsType {
             ConsType::Service(serv) => {
                 let mut res = Vec::new();
                 let mut prev = None;
-                for m in serv.meths.iter() {
+                for m in &serv.meths {
                     if let Some(prev) = prev {
                         if prev >= &m.name {
                             return Err(anyhow!("method name {} duplicate or not sorted", m.name));
@@ -242,9 +242,9 @@ impl Table {
             env.insert(index_to_var(i as i64), ty);
         }
         // validate method has func type
-        for (_, t) in env.iter() {
+        for t in env.values() {
             if let TypeInner::Service(ms) = t.as_ref() {
-                for (name, ty) in ms.iter() {
+                for (name, ty) in ms {
                     if let TypeInner::Var(id) = ty.as_ref() {
                         if matches!(env.get(id).map(|t| t.as_ref()), Some(TypeInner::Func(_))) {
                             continue;
diff --git a/rust/candid/src/bindings/mod.rs b/rust/candid/src/bindings/mod.rs
deleted file mode 100644
index 89d86ab3..00000000
--- a/rust/candid/src/bindings/mod.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//! Candid bindings for different languages.
-// This module assumes the input are type checked, it is safe to use unwrap.
-
-pub mod candid;
-
-#[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-#[cfg(feature = "parser")]
-pub mod analysis;
-#[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-#[cfg(feature = "parser")]
-pub mod javascript;
-#[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-#[cfg(feature = "parser")]
-pub mod motoko;
-#[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-#[cfg(feature = "parser")]
-pub mod rust;
-#[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-#[cfg(feature = "parser")]
-pub mod typescript;
diff --git a/rust/candid/src/de.rs b/rust/candid/src/de.rs
index 036440c6..67d88e14 100644
--- a/rust/candid/src/de.rs
+++ b/rust/candid/src/de.rs
@@ -4,11 +4,13 @@ use super::{
     error::{Error, Result},
     types::internal::{text_size, type_of, TypeId},
     types::{Field, Label, SharedLabel, Type, TypeEnv, TypeInner},
-    CandidType, Int, Nat,
+    CandidType,
 };
+#[cfg(feature = "bignum")]
+use super::{Int, Nat};
 use crate::{
     binary_parser::{BoolValue, Header, Len, PrincipalBytes},
-    types::subtype::{subtype, Gamma},
+    types::subtype::{subtype_with_config, Gamma, OptReport},
 };
 use anyhow::{anyhow, Context};
 use binread::BinRead;
@@ -56,6 +58,9 @@ impl<'de> IDLDeserialize<'de> {
         self.de.is_untyped = false;
         self.deserialize_with_type(T::ty())
     }
+    #[cfg_attr(docsrs, doc(cfg(feature = "value")))]
+    #[cfg(feature = "value")]
+    /// Deserialize one value as `IDLValue` from deserializer. Note that `expected_type` should not contain `TypeInner::Knot`.
     pub fn get_value_with_type(
         &mut self,
         env: &TypeEnv,
@@ -136,8 +141,29 @@ impl<'de> IDLDeserialize<'de> {
 }
 
 pub struct Config {
-    pub zero_sized_values: usize,
-    pub full_error_message: bool,
+    zero_sized_values: usize,
+    full_error_message: bool,
+}
+impl Config {
+    pub fn new() -> Self {
+        Self {
+            zero_sized_values: 2_000_000,
+            full_error_message: true,
+        }
+    }
+    pub fn set_zero_sized_values(&mut self, n: usize) -> &mut Self {
+        self.zero_sized_values = n;
+        self
+    }
+    pub fn set_full_error_message(&mut self, n: bool) -> &mut Self {
+        self.full_error_message = n;
+        self
+    }
+}
+impl Default for Config {
+    fn default() -> Self {
+        Self::new()
+    }
 }
 
 macro_rules! assert {
@@ -273,7 +299,8 @@ impl<'de> Deserializer<'de> {
         Ok(res)
     }
     fn check_subtype(&mut self) -> Result<()> {
-        subtype(
+        subtype_with_config(
+            OptReport::Silence,
             &mut self.gamma,
             &self.table,
             &self.wire_type,
@@ -332,9 +359,11 @@ impl<'de> Deserializer<'de> {
     // 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), service(4), function(5)
+    // int(0), nat(1), principal(2), reserved(3), service(4), function(5), blob(6)
     // This is necessary for deserializing IDLValue because
     // it has only one visitor and we need a way to know who called the visitor.
+    #[cfg_attr(docsrs, doc(cfg(feature = "bignum")))]
+    #[cfg(feature = "bignum")]
     fn deserialize_int<'a, V>(&'a mut self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
@@ -354,6 +383,8 @@ impl<'de> Deserializer<'de> {
         bytes.extend_from_slice(&int.0.to_signed_bytes_le());
         visitor.visit_byte_buf(bytes)
     }
+    #[cfg_attr(docsrs, doc(cfg(feature = "bignum")))]
+    #[cfg(feature = "bignum")]
     fn deserialize_nat<'a, V>(&'a mut self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
@@ -419,6 +450,22 @@ impl<'de> Deserializer<'de> {
         bytes.extend_from_slice(&id);
         visitor.visit_byte_buf(bytes)
     }
+    fn deserialize_blob<'a, V>(&'a mut self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.unroll_type()?;
+        check!(
+            self.expect_type.is_blob(&self.table) && self.wire_type.is_blob(&self.table),
+            "blob"
+        );
+        let len = Len::read(&mut self.input)?.0;
+        let blob = self.borrow_bytes(len)?;
+        let mut bytes = Vec::with_capacity(len + 1);
+        bytes.push(6u8);
+        bytes.extend_from_slice(blob);
+        visitor.visit_byte_buf(bytes)
+    }
     fn deserialize_empty<'a, V>(&'a mut self, _visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
@@ -449,14 +496,19 @@ impl<'de> Deserializer<'de> {
     {
         use de::Deserializer;
         let tid = type_of(&visitor);
-        if tid != TypeId::of::<crate::types::value::IDLValueVisitor>() // derive Copy
-            && tid != TypeId::of::<de::IgnoredAny>() // derive Copy
+        if tid != TypeId::of::<de::IgnoredAny>() // derive Copy
         // OptionVisitor doesn't derive Copy, but has only PhantomData.
         // OptionVisitor is private and we cannot get TypeId of OptionVisitor<T>,
         // we also cannot downcast V to concrete type, because of 'de
         // The only option left seems to be type_name, but it is not guaranteed to be stable, so there is risk here.
             && !tid.name.starts_with("serde::de::impls::OptionVisitor<")
         {
+            #[cfg(feature = "value")]
+            if tid != TypeId::of::<crate::types::value::IDLValueVisitor>() {
+                // derive Copy
+                panic!("Not a valid visitor: {tid:?}");
+            }
+            #[cfg(not(feature = "value"))]
             panic!("Not a valid visitor: {tid:?}");
         }
         // This is safe, because the visitor either impl Copy or is zero sized
@@ -501,8 +553,14 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         }
         self.unroll_type()?;
         match self.expect_type.as_ref() {
+            #[cfg(feature = "bignum")]
             TypeInner::Int => self.deserialize_int(visitor),
+            #[cfg(not(feature = "bignum"))]
+            TypeInner::Int => self.deserialize_i128(visitor),
+            #[cfg(feature = "bignum")]
             TypeInner::Nat => self.deserialize_nat(visitor),
+            #[cfg(not(feature = "bignum"))]
+            TypeInner::Nat => self.deserialize_u128(visitor),
             TypeInner::Nat8 => self.deserialize_u8(visitor),
             TypeInner::Nat16 => self.deserialize_u16(visitor),
             TypeInner::Nat32 => self.deserialize_u32(visitor),
@@ -526,6 +584,10 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
             TypeInner::Principal => self.deserialize_principal(visitor),
             // construct types
             TypeInner::Opt(_) => self.deserialize_option(visitor),
+            // This is an optimization for blob, mostly likely used by IDLValue, but it won't help the native Vec<u8>
+            TypeInner::Vec(_) if self.expect_type.is_blob(&self.table) => {
+                self.deserialize_blob(visitor)
+            }
             TypeInner::Vec(_) => self.deserialize_seq(visitor),
             TypeInner::Record(_) => self.deserialize_struct("_", &[], visitor),
             TypeInner::Variant(_) => self.deserialize_enum("_", &[], visitor),
@@ -564,22 +626,13 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        use num_traits::ToPrimitive;
+        use crate::types::leb128::{decode_int, decode_nat};
         self.unroll_type()?;
         assert!(*self.expect_type == TypeInner::Int);
         let value: i128 = match self.wire_type.as_ref() {
-            TypeInner::Int => {
-                let int = Int::decode(&mut self.input).map_err(Error::msg)?;
-                int.0
-                    .to_i128()
-                    .ok_or_else(|| Error::msg("Cannot convert int to i128"))?
-            }
-            TypeInner::Nat => {
-                let nat = Nat::decode(&mut self.input).map_err(Error::msg)?;
-                nat.0
-                    .to_i128()
-                    .ok_or_else(|| Error::msg("Cannot convert nat to i128"))?
-            }
+            TypeInner::Int => decode_int(&mut self.input)?,
+            TypeInner::Nat => i128::try_from(decode_nat(&mut self.input)?)
+                .map_err(|_| Error::msg("Cannot convert nat to i128"))?,
             t => return Err(Error::subtype(format!("{t} cannot be deserialized to int"))),
         };
         visitor.visit_i128(value)
@@ -588,17 +641,12 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        use num_traits::ToPrimitive;
         self.unroll_type()?;
         check!(
             *self.expect_type == TypeInner::Nat && *self.wire_type == TypeInner::Nat,
             "nat"
         );
-        let nat = Nat::decode(&mut self.input).map_err(Error::msg)?;
-        let value = nat
-            .0
-            .to_u128()
-            .ok_or_else(|| Error::msg("Cannot convert nat to u128"))?;
+        let value = crate::types::leb128::decode_nat(&mut self.input)?;
         visitor.visit_u128(value)
     }
     fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
@@ -671,9 +719,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     {
         self.unroll_type()?;
         match (self.wire_type.as_ref(), self.expect_type.as_ref()) {
-            (TypeInner::Null, TypeInner::Opt(_)) | (TypeInner::Reserved, TypeInner::Opt(_)) => {
-                visitor.visit_none()
-            }
+            (TypeInner::Null | TypeInner::Reserved, TypeInner::Opt(_)) => visitor.visit_none(),
             (TypeInner::Opt(t1), TypeInner::Opt(t2)) => {
                 self.wire_type = t1.clone();
                 self.expect_type = t2.clone();
diff --git a/rust/candid/src/error.rs b/rust/candid/src/error.rs
index 9181d4a0..39cf280b 100644
--- a/rust/candid/src/error.rs
+++ b/rust/candid/src/error.rs
@@ -1,30 +1,21 @@
 //! `candid::Result<T> = Result<T, candid::Error>>`
 
-use codespan_reporting::diagnostic::Label;
 use serde::{de, ser};
-use std::io;
+use std::{io, num::ParseIntError};
 use thiserror::Error;
 
-#[cfg(feature = "parser")]
-use crate::parser::token;
-#[cfg(feature = "parser")]
-use codespan_reporting::{
-    diagnostic::Diagnostic,
-    files::{Error as ReportError, SimpleFile},
-    term::{self, termcolor::StandardStream},
-};
-
 pub type Result<T = ()> = std::result::Result<T, Error>;
 
+#[derive(Debug)]
+pub struct Label {
+    pos: usize,
+    message: String,
+}
+
 #[derive(Debug, Error)]
 pub enum Error {
-    #[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-    #[cfg(feature = "parser")]
-    #[error("Candid parser error: {0}")]
-    Parse(#[from] token::ParserError),
-
-    #[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("binary parser error: {}", .0.get(0).map_or_else(|| "io error".to_string(), |f| format!("{} at byte offset {}", f.message, f.pos/2)))]
+    Binread(Vec<Label>),
 
     #[error("Subtyping error: {0}")]
     Subtype(String),
@@ -40,57 +31,27 @@ impl Error {
     pub fn subtype<T: ToString>(msg: T) -> Self {
         Error::Subtype(msg.to_string())
     }
-    #[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-    #[cfg(feature = "parser")]
-    pub fn report(&self) -> Diagnostic<()> {
-        match self {
-            Error::Parse(e) => {
-                use lalrpop_util::ParseError::*;
-                let mut diag = Diagnostic::error().with_message("parser error");
-                let label = match e {
-                    User { error } => {
-                        Label::primary((), error.span.clone()).with_message(&error.err)
-                    }
-                    InvalidToken { location } => {
-                        Label::primary((), *location..location + 1).with_message("Invalid token")
-                    }
-                    UnrecognizedEof { location, expected } => {
-                        diag = diag.with_notes(report_expected(expected));
-                        Label::primary((), *location..location + 1).with_message("Unexpected EOF")
-                    }
-                    UnrecognizedToken { token, expected } => {
-                        diag = diag.with_notes(report_expected(expected));
-                        Label::primary((), token.0..token.2).with_message("Unexpected token")
-                    }
-                    ExtraToken { token } => {
-                        Label::primary((), token.0..token.2).with_message("Extra token")
-                    }
-                };
-                diag.with_labels(vec![label])
-            }
-            Error::Binread(labels) => {
-                let diag = Diagnostic::error().with_message("decoding error");
-                diag.with_labels(labels.to_vec())
-            }
-            Error::Subtype(e) => Diagnostic::error().with_message(e),
-            Error::Custom(e) => Diagnostic::error().with_message(e.to_string()),
-        }
-    }
 }
 
-fn get_binread_labels(e: &binread::Error) -> Vec<Label<()>> {
+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")]
+            vec![Label {
+                pos,
+                message: "Unexpected bytes".to_string(),
+            }]
         }
         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())]
+            vec![Label {
+                pos,
+                message: (*err).to_string(),
+            }]
         }
         EnumErrors {
             pos,
@@ -102,47 +63,39 @@ fn get_binread_labels(e: &binread::Error) -> Vec<Label<()>> {
                 .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")],
+                None => vec![Label {
+                    pos,
+                    message: "Unknown opcode".to_string(),
+                }],
                 Some((id, e)) => {
                     let mut labels = get_binread_labels(e);
-                    labels.push(Label::secondary((), pos..pos + 2).with_message(id.to_string()));
+                    labels.push(Label {
+                        pos,
+                        message: (*id).to_string(),
+                    });
                     labels
                 }
             }
         }
         NoVariantMatch { pos } => {
             let pos = (pos * 2) as usize;
-            vec![Label::primary((), pos..pos + 2).with_message("No variant match")]
+            vec![Label {
+                pos,
+                message: "No variant match".to_string(),
+            }]
         }
         AssertFail { pos, message } => {
             let pos = (pos * 2) as usize;
-            vec![Label::primary((), pos..pos + 2).with_message(message)]
+            vec![Label {
+                pos,
+                message: message.to_string(),
+            }]
         }
         Io(_) => vec![],
         _ => unreachable!(),
     }
 }
 
-#[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-#[cfg(feature = "parser")]
-fn report_expected(expected: &[String]) -> Vec<String> {
-    if expected.is_empty() {
-        return Vec::new();
-    }
-    use pretty::RcDoc;
-    let doc: RcDoc<()> = RcDoc::intersperse(
-        expected.iter().map(RcDoc::text),
-        RcDoc::text(",").append(RcDoc::softline()),
-    );
-    let header = if expected.len() == 1 {
-        "Expects"
-    } else {
-        "Expects one of"
-    };
-    let doc = RcDoc::text(header).append(RcDoc::softline().append(doc));
-    vec![doc.pretty(70).to_string()]
-}
-
 impl ser::Error for Error {
     fn custom<T: std::fmt::Display>(msg: T) -> Self {
         Error::msg(format!("Serialize error: {msg}"))
@@ -174,56 +127,9 @@ impl From<binread::Error> for Error {
         Error::Binread(get_binread_labels(&e))
     }
 }
-#[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-#[cfg(feature = "parser")]
-impl From<ReportError> for Error {
-    fn from(e: ReportError) -> Error {
-        Error::msg(e)
-    }
-}
-#[cfg_attr(docsrs, doc(cfg(feature = "random")))]
-#[cfg(feature = "random")]
-impl From<arbitrary::Error> for Error {
-    fn from(e: arbitrary::Error) -> Error {
-        Error::msg(format!("arbitrary error: {e}"))
-    }
-}
 
-#[cfg_attr(docsrs, doc(cfg(feature = "configs")))]
-#[cfg(feature = "configs")]
-impl From<serde_dhall::Error> for Error {
-    fn from(e: serde_dhall::Error) -> Error {
-        Error::msg(format!("dhall error: {e}"))
+impl From<ParseIntError> for Error {
+    fn from(e: ParseIntError) -> Error {
+        Error::msg(format!("ParseIntError: {e}"))
     }
 }
-
-#[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-#[cfg(feature = "parser")]
-pub fn pretty_parse<T>(name: &str, str: &str) -> Result<T>
-where
-    T: std::str::FromStr<Err = Error>,
-{
-    str.parse::<T>().or_else(|e| {
-        let writer = StandardStream::stderr(term::termcolor::ColorChoice::Auto);
-        let config = term::Config::default();
-        let file = SimpleFile::new(name, str);
-        term::emit(&mut writer.lock(), &config, &file, &e.report())?;
-        Err(e)
-    })
-}
-#[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-#[cfg(feature = "parser")]
-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 446735af..fe45f4aa 100644
--- a/rust/candid/src/lib.rs
+++ b/rust/candid/src/lib.rs
@@ -79,6 +79,8 @@
 //! This is difficult to achieve in `Serialize`, especially for enum types. Besides serialization, [`CandidType`](types/trait.CandidType.html)
 //! trait also converts Rust type to Candid type defined as [`candid::types::Type`](types/internal/enum.Type.html).
 //! ```
+//! #[cfg(feature = "serde_bytes")]
+//! # fn f() -> Result<(), candid::Error> {
 //! use candid::{Encode, Decode, CandidType, Deserialize};
 //! #[derive(CandidType, Deserialize)]
 //! # #[derive(Debug, PartialEq)]
@@ -94,7 +96,8 @@
 //! let bytes = Encode!(&list)?;
 //! let res = Decode!(&bytes, List)?;
 //! assert_eq!(res, list);
-//! # Ok::<(), candid::Error>(())
+//! # Ok(())
+//! # }
 //! ```
 //! We support serde's rename attributes for each field, namely `#[serde(rename = "foo")]`
 //! and `#[serde(rename(serialize = "foo", deserialize = "foo"))]`.
@@ -113,14 +116,17 @@
 //! You can also use `i128` and `u128` to represent Candid `int` and `nat` types respectively (decoding will fail if
 //! the number is more than 128 bits).
 //! ```
+//! #[cfg(feature = "bignum")]
+//! # fn f() -> Result<(), candid::Error> {
 //! use candid::{Int, Nat, Encode, Decode};
 //! let x = "-10000000000000000000".parse::<Int>()?;
-//! let bytes = Encode!(&Nat::from(1024), &x)?;
+//! let bytes = Encode!(&Nat::from(1024u32), &x)?;
 //! let (a, b) = Decode!(&bytes, Nat, Int)?;
 //! let (c, d) = Decode!(&bytes, u128, i128)?;
-//! assert_eq!(a + 1, 1025);
+//! assert_eq!(a + 1u8, 1025u32);
 //! assert_eq!(b, Int::parse(b"-10000000000000000000")?);
-//! # Ok::<(), candid::Error>(())
+//! # Ok(())
+//! # }
 //! ```
 //!
 //! ## Operating on reference types
@@ -129,6 +135,8 @@
 //! instead of the Candid types.
 //!
 //! ```
+//! #[cfg(feature = "bignum")]
+//! # fn f() -> Result<(), candid::Error> {
 //! use candid::{define_function, define_service, func, Encode, Decode, Principal};
 //! let principal = Principal::from_text("aaaaa-aa").unwrap();
 //!
@@ -142,7 +150,8 @@
 //! });
 //! let serv = MyService::new(principal);
 //! assert_eq!(serv, Decode!(&Encode!(&serv)?, MyService)?);
-//! # Ok::<(), candid::Error>(())
+//! # Ok(())
+//! # }
 //! ```
 //!
 //! ## Operating on untyped Candid values
@@ -151,6 +160,8 @@
 //! The use of Rust value and `IDLValue` can be intermixed.
 //!
 //! ```
+//! #[cfg(feature = "value")]
+//! # fn f() -> Result<(), candid::Error> {
 //! use candid::types::value::IDLValue;
 //! // Serialize Rust value Some(42u8) and IDLValue "hello"
 //! let bytes = candid::ser::IDLBuilder::new()
@@ -167,110 +178,6 @@
 //!
 //! assert_eq!(x, IDLValue::Opt(Box::new(IDLValue::Nat8(42))));
 //! assert_eq!(y, "hello");
-//! # Ok::<(), candid::Error>(())
-//! ```
-//!
-//! We provide a data structure [`candid::IDLArgs`](parser/value/struct.IDLArgs.html) to represent a sequence of `IDLValue`s,
-//! and use `to_bytes()` and `from_bytes()` to encode and decode Candid messages.
-//! We also provide a parser to parse Candid values in text format.
-//!
-//! ```
-//! #[cfg(feature = "parser")]
-//! # fn f() -> Result<(), candid::Error> {
-//! use candid::{IDLArgs, TypeEnv};
-//! // Candid values represented in text format
-//! let text_value = r#"
-//!      (42, opt true, vec {1;2;3},
-//!       opt record {label="text"; 42="haha"})
-//! "#;
-//!
-//! // Parse text format into IDLArgs for serialization
-//! let args: IDLArgs = text_value.parse()?;
-//! let encoded: Vec<u8> = args.to_bytes()?;
-//!
-//! // Deserialize into IDLArgs
-//! let decoded: IDLArgs = IDLArgs::from_bytes(&encoded)?;
-//! assert_eq!(encoded, decoded.to_bytes()?);
-//!
-//! // Convert IDLArgs to text format
-//! let output: String = decoded.to_string();
-//! let parsed_args: IDLArgs = output.parse()?;
-//! let annotated_args = args.annotate_types(true, &TypeEnv::new(), &parsed_args.get_types())?;
-//! assert_eq!(annotated_args, parsed_args);
-//! # Ok(())
-//! # }
-//! ```
-//! Note that when parsing Candid values, we assume the number literals are always of type `Int`.
-//! This can be changed by providing the type of the method arguments, which can usually be obtained
-//! by parsing a Candid file in the following section.
-//!
-//! ## Operating on Candid AST
-//! We provide a parser and type checker for Candid files specifying the service interface.
-//!
-//! ```
-//! #[cfg(feature = "parser")]
-//! # fn f() -> Result<(), candid::Error> {
-//! use candid::{IDLProg, TypeEnv, check_prog, types::{Type, TypeInner}};
-//! let did_file = r#"
-//!     type List = opt record { head: int; tail: List };
-//!     type byte = nat8;
-//!     service : {
-//!       f : (byte, int, nat, int8) -> (List);
-//!       g : (List) -> (int) query;
-//!     }
-//! "#;
-//!
-//! // Parse did file into an AST
-//! let ast: IDLProg = did_file.parse()?;
-//!
-//! // Type checking a given .did file
-//! // let (env, opt_actor) = check_file("a.did")?;
-//! // Or alternatively, use check_prog to check in-memory did file
-//! // Note that file import is ignored by check_prog.
-//! let mut env = TypeEnv::new();
-//! let actor: Type = check_prog(&mut env, &ast)?.unwrap();
-//!
-//! let method = env.get_method(&actor, "g").unwrap();
-//! assert_eq!(method.is_query(), true);
-//! assert_eq!(method.args, vec![TypeInner::Var("List".to_string()).into()]);
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! ## Serializing untyped Candid values with type annotations.
-//! With type signatures from the Candid file, [`candid::IDLArgs`](parser/value/struct.IDLArgs.html)
-//! uses `to_bytes_with_types` function to serialize arguments directed by the Candid types.
-//! This is useful when serializing different number types and recursive types.
-//! There is no need to use types for deserialization as the types are available in the Candid message.
-//!
-//! ```
-//! #[cfg(feature = "parser")]
-//! # fn f() -> Result<(), candid::Error> {
-//! use candid::{IDLArgs, types::value::IDLValue};
-//! # use candid::{IDLProg, TypeEnv, check_prog};
-//! # let did_file = r#"
-//! #    type List = opt record { head: int; tail: List };
-//! #    type byte = nat8;
-//! #    service : {
-//! #      f : (byte, int, nat, int8) -> (List);
-//! #      g : (List) -> (int) query;
-//! #    }
-//! # "#;
-//! # let ast = did_file.parse::<IDLProg>()?;
-//! # let mut env = TypeEnv::new();
-//! # let actor = check_prog(&mut env, &ast)?.unwrap();
-//! // Get method type f : (byte, int, nat, int8) -> (List)
-//! let method = env.get_method(&actor, "f").unwrap();
-//! let args = "(42, 42, 42, 42)".parse::<IDLArgs>()?;
-//! // Serialize arguments with candid types
-//! let encoded = args.to_bytes_with_types(&env, &method.args)?;
-//! let decoded = IDLArgs::from_bytes(&encoded)?;
-//! assert_eq!(decoded.args,
-//!        vec![IDLValue::Nat8(42),
-//!             IDLValue::Int(42.into()),
-//!             IDLValue::Nat(42.into()),
-//!             IDLValue::Int8(42)
-//!            ]);
 //! # Ok(())
 //! # }
 //! ```
@@ -287,6 +194,7 @@
 //! [dependencies]
 //! wasm-bindgen = "0.2"
 //! candid = "0.9.0"
+//! candid_parser = "0.1.0"
 //!
 //! [profile.release]
 //! lto = true
@@ -294,14 +202,15 @@
 //! ```
 //! Expose the methods in `lib.rs`
 //! ```ignore
-//! use candid::{check_prog, IDLProg, TypeEnv};
+//! use candid::TypeEnv;
+//! use candid_parser::{check_prog, IDLProg};
 //! use wasm_bindgen::prelude::*;
 //! #[wasm_bindgen]
 //! pub fn did_to_js(prog: String) -> Option<String> {
 //!   let ast = prog.parse::<IDLProg>().ok()?;
 //!   let mut env = TypeEnv::new();
 //!   let actor = check_prog(&mut env, &ast).ok()?;
-//!   Some(candid::bindings::javascript::compile(&env, &actor))
+//!   Some(candid_parser::bindings::javascript::compile(&env, &actor))
 //! }
 //! ```
 //! ### Building
@@ -332,15 +241,15 @@ pub mod error;
 pub use error::{Error, Result};
 
 pub mod types;
+#[cfg(feature = "bignum")]
+pub use types::number::{Int, Nat};
 pub use types::CandidType;
 pub use types::{
     arc,
-    number::{Int, Nat},
     principal::Principal,
     rc,
     reference::{Func, Service},
     reserved::{Empty, Reserved},
-    value::{IDLArgs, IDLValue},
     TypeEnv,
 };
 
@@ -351,20 +260,13 @@ pub mod ser;
 
 pub mod utils;
 pub use utils::{decode_args, decode_one, encode_args, encode_one, write_args};
-pub mod pretty;
-
-#[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-#[cfg(feature = "parser")]
-pub mod parser;
-#[cfg(feature = "parser")]
-pub use error::{pretty_parse, pretty_read};
-#[cfg(feature = "parser")]
-pub use parser::{
-    types::IDLProg,
-    typing::{check_file, check_prog, pretty_check_file},
-};
 
-pub mod bindings;
+#[cfg_attr(docsrs, doc(cfg(feature = "value")))]
+#[cfg(feature = "value")]
+pub use types::value::{IDLArgs, IDLValue};
+#[cfg_attr(docsrs, doc(cfg(feature = "printer")))]
+#[cfg(feature = "printer")]
+pub mod pretty;
 
 // Candid hash function comes from
 // https://caml.inria.fr/pub/papers/garrigue-polymorphic_variants-ml98.pdf
@@ -374,7 +276,7 @@ pub mod bindings;
 #[inline]
 pub fn idl_hash(id: &str) -> u32 {
     let mut s: u32 = 0;
-    for c in id.as_bytes().iter() {
+    for c in id.as_bytes() {
         s = s.wrapping_mul(223).wrapping_add(*c as u32);
     }
     s
diff --git a/rust/candid/src/parser/grammar.rs b/rust/candid/src/parser/grammar.rs
deleted file mode 100644
index 2f39e7f0..00000000
--- a/rust/candid/src/parser/grammar.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-#![allow(clippy::all)]
-include!(concat!(env!("OUT_DIR"), "/parser/grammar.rs"));
diff --git a/rust/candid/src/parser/mod.rs b/rust/candid/src/parser/mod.rs
deleted file mode 100644
index 6c4c399c..00000000
--- a/rust/candid/src/parser/mod.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//! Provides parser for Candid type and value.
-//!  * `str.parse::<IDLProg>()` parses the Candid signature file to Candid AST.
-//!  * `str.parse::<IDLArgs>()` parses the Candid value in text format to a struct `IDLArg` that can be used for serialization and deserialization between Candid and an enum type `IDLValue` in Rust.
-
-pub mod grammar;
-
-pub mod token;
-pub mod types;
-
-pub mod typing;
-
-#[cfg_attr(docsrs, doc(cfg(feature = "configs")))]
-#[cfg(feature = "configs")]
-pub mod configs;
-#[cfg_attr(docsrs, doc(cfg(feature = "random")))]
-#[cfg(feature = "random")]
-pub mod random;
-pub mod test;
-
-pub use crate::types::value::{IDLArgs, IDLValue};
-
-impl std::str::FromStr for IDLArgs {
-    type Err = crate::Error;
-    fn from_str(str: &str) -> std::result::Result<Self, Self::Err> {
-        let lexer = token::Tokenizer::new(str);
-        Ok(grammar::ArgsParser::new().parse(lexer)?)
-    }
-}
-
-impl std::str::FromStr for IDLValue {
-    type Err = crate::Error;
-    fn from_str(str: &str) -> std::result::Result<Self, Self::Err> {
-        let lexer = token::Tokenizer::new(str);
-        Ok(grammar::ArgParser::new().parse(lexer)?)
-    }
-}
diff --git a/rust/candid/src/bindings/candid.rs b/rust/candid/src/pretty/candid.rs
similarity index 92%
rename from rust/candid/src/bindings/candid.rs
rename to rust/candid/src/pretty/candid.rs
index ffe4d8d3..ea13fe98 100644
--- a/rust/candid/src/bindings/candid.rs
+++ b/rust/candid/src/pretty/candid.rs
@@ -1,5 +1,5 @@
-use crate::pretty::*;
-use crate::types::{Field, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
+use crate::pretty::utils::*;
+use crate::types::{Field, FuncMode, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
 use pretty::RcDoc;
 
 static KEYWORDS: [&str; 30] = [
@@ -39,7 +39,7 @@ fn is_keyword(id: &str) -> bool {
     KEYWORDS.contains(&id)
 }
 
-pub(crate) fn is_valid_as_id(id: &str) -> bool {
+pub fn is_valid_as_id(id: &str) -> bool {
     if id.is_empty() || !id.is_ascii() {
         return false;
     }
@@ -160,9 +160,15 @@ pub fn pp_args(args: &[Type]) -> RcDoc {
     let doc = concat(args.iter().map(pp_ty), ",");
     enclose("(", doc, ")")
 }
-
-pub(crate) fn pp_modes(modes: &[crate::types::FuncMode]) -> RcDoc {
-    RcDoc::concat(modes.iter().map(|m| RcDoc::space().append(m.to_doc())))
+pub fn pp_mode(mode: &FuncMode) -> RcDoc {
+    match mode {
+        FuncMode::Oneway => RcDoc::text("oneway"),
+        FuncMode::Query => RcDoc::text("query"),
+        FuncMode::CompositeQuery => RcDoc::text("composite_query"),
+    }
+}
+pub fn pp_modes(modes: &[FuncMode]) -> RcDoc {
+    RcDoc::concat(modes.iter().map(|m| RcDoc::space().append(pp_mode(m))))
 }
 
 fn pp_service(serv: &[(String, Type)]) -> RcDoc {
@@ -210,15 +216,19 @@ pub fn compile(env: &TypeEnv, actor: &Option<Type>) -> String {
     }
 }
 
+#[cfg_attr(docsrs, doc(cfg(feature = "value")))]
+#[cfg(feature = "value")]
 pub mod value {
-    use crate::bindings::candid::{ident_string, pp_text};
-    use crate::pretty::*;
+    use super::{ident_string, pp_text};
+    use crate::pretty::utils::*;
     use crate::types::value::{IDLArgs, IDLField, IDLValue};
-    use crate::types::{number::pp_num_str, Label};
+    use crate::types::Label;
+    use crate::utils::pp_num_str;
     use std::fmt;
 
     use ::pretty::RcDoc;
 
+    // TODO config this
     const MAX_ELEMENTS_FOR_PRETTY_PRINT: usize = 10;
 
     impl fmt::Display for IDLArgs {
@@ -285,14 +295,14 @@ pub mod value {
             Int32(n) => pp_num_str(&n.to_string()),
             Int64(n) => pp_num_str(&n.to_string()),
             Float32(f) => {
-                if f.trunc() == *f {
+                if f.is_finite() && f.trunc() == *f {
                     format!("{f}.0")
                 } else {
                     f.to_string()
                 }
             }
             Float64(f) => {
-                if f.trunc() == *f {
+                if f.is_finite() && f.trunc() == *f {
                     format!("{f}.0")
                 } else {
                     f.to_string()
@@ -325,14 +335,16 @@ pub mod value {
                 Reserved => write!(f, "null : reserved"),
                 Principal(id) => write!(f, "principal \"{id}\""),
                 Service(id) => write!(f, "service \"{id}\""),
-                Func(id, meth) => write!(
-                    f,
-                    "func \"{}\".{}",
-                    id,
-                    crate::bindings::candid::ident_string(meth)
-                ),
+                Func(id, meth) => write!(f, "func \"{}\".{}", id, ident_string(meth)),
                 Opt(v) if has_type_annotation(v) => write!(f, "opt ({v:?})"),
                 Opt(v) => write!(f, "opt {v:?}"),
+                Blob(b) => {
+                    write!(f, "blob \"")?;
+                    for v in b.iter() {
+                        write!(f, "{}", &pp_char(*v))?;
+                    }
+                    write!(f, "\"")
+                }
                 Vec(vs) => {
                     if let Some(Nat8(_)) = vs.first() {
                         write!(f, "blob \"")?;
diff --git a/rust/candid/src/pretty/mod.rs b/rust/candid/src/pretty/mod.rs
new file mode 100644
index 00000000..7797e8dc
--- /dev/null
+++ b/rust/candid/src/pretty/mod.rs
@@ -0,0 +1,4 @@
+//! pretty printer for Candid type and value
+
+pub mod candid;
+pub mod utils;
diff --git a/rust/candid/src/pretty.rs b/rust/candid/src/pretty/utils.rs
similarity index 90%
rename from rust/candid/src/pretty.rs
rename to rust/candid/src/pretty/utils.rs
index 937a0885..89e92fdf 100644
--- a/rust/candid/src/pretty.rs
+++ b/rust/candid/src/pretty/utils.rs
@@ -7,11 +7,8 @@ fn is_empty(doc: &RcDoc) -> bool {
     use pretty::Doc::*;
     match &**doc {
         Nil => true,
-        FlatAlt(t1, t2) => is_empty(t1) && is_empty(t2),
-        Group(t) => is_empty(t),
-        Nest(_, t) => is_empty(t),
-        Union(t1, t2) => is_empty(t1) && is_empty(t2),
-        Annotated(_, t) => is_empty(t),
+        FlatAlt(t1, t2) | Union(t1, t2) => is_empty(t1) && is_empty(t2),
+        Group(t) | Nest(_, t) | Annotated((), t) => is_empty(t),
         _ => false,
     }
 }
diff --git a/rust/candid/src/ser.rs b/rust/candid/src/ser.rs
index e36e7032..8da313d0 100644
--- a/rust/candid/src/ser.rs
+++ b/rust/candid/src/ser.rs
@@ -2,6 +2,7 @@
 
 use super::error::{Error, Result};
 use super::types;
+#[cfg(feature = "value")]
 use super::types::value::IDLValue;
 use super::types::{internal::Opcode, Field, Type, TypeEnv, TypeInner};
 use byteorder::{LittleEndian, WriteBytesExt};
@@ -33,12 +34,16 @@ impl IDLBuilder {
         value.idl_serialize(&mut self.value_ser)?;
         Ok(self)
     }
+    #[cfg_attr(docsrs, doc(cfg(feature = "value")))]
+    #[cfg(feature = "value")]
     pub fn value_arg<'a>(&'a mut self, value: &IDLValue) -> Result<&'a mut Self> {
         use super::CandidType;
         self.type_ser.push_type(&value.value_ty())?;
         value.idl_serialize(&mut self.value_ser)?;
         Ok(self)
     }
+    #[cfg_attr(docsrs, doc(cfg(feature = "value")))]
+    #[cfg(feature = "value")]
     /// Annotate IDLValue with (TypeEnv, Type). Note that the TypeEnv will be added to the serializer state.
     /// If the Type can already be resolved by previous TypeEnvs, you don't need to pass TypeEnv again.
     pub fn value_arg_with_type<'a>(
@@ -114,12 +119,20 @@ impl<'a> types::Serializer for &'a mut ValueSerializer {
         self.write(&[v as u8])?;
         Ok(())
     }
+    #[cfg(feature = "bignum")]
     fn serialize_int(self, v: &crate::Int) -> Result<()> {
         v.encode(&mut self.value)
     }
+    #[cfg(feature = "bignum")]
     fn serialize_nat(self, v: &crate::Nat) -> Result<()> {
         v.encode(&mut self.value)
     }
+    fn serialize_i128(self, v: i128) -> Result<()> {
+        crate::types::leb128::encode_int(&mut self.value, v)
+    }
+    fn serialize_u128(self, v: u128) -> Result<()> {
+        crate::types::leb128::encode_nat(&mut self.value, v)
+    }
     serialize_num!(nat8, u8, write_u8);
     serialize_num!(nat16, u16, write_u16::<LittleEndian>);
     serialize_num!(nat32, u32, write_u32::<LittleEndian>);
@@ -272,36 +285,36 @@ impl TypeSerialize {
                 self.encode(&mut buf, ty)?;
             }
             TypeInner::Record(fs) => {
-                for Field { ty, .. } in fs.iter() {
+                for Field { ty, .. } in fs {
                     self.build_type(ty)?;
                 }
 
                 sleb128_encode(&mut buf, Opcode::Record as i64)?;
                 leb128_encode(&mut buf, fs.len() as u64)?;
-                for Field { id, ty } in fs.iter() {
+                for Field { id, ty } in fs {
                     leb128_encode(&mut buf, u64::from(id.get_id()))?;
                     self.encode(&mut buf, ty)?;
                 }
             }
             TypeInner::Variant(fs) => {
-                for Field { ty, .. } in fs.iter() {
+                for Field { ty, .. } in fs {
                     self.build_type(ty)?;
                 }
 
                 sleb128_encode(&mut buf, Opcode::Variant as i64)?;
                 leb128_encode(&mut buf, fs.len() as u64)?;
-                for Field { id, ty } in fs.iter() {
+                for Field { id, ty } in fs {
                     leb128_encode(&mut buf, u64::from(id.get_id()))?;
                     self.encode(&mut buf, ty)?;
                 }
             }
             TypeInner::Service(ref ms) => {
-                for (_, ty) in ms.iter() {
+                for (_, ty) in ms {
                     self.build_type(ty)?;
                 }
                 sleb128_encode(&mut buf, Opcode::Service as i64)?;
                 leb128_encode(&mut buf, ms.len() as u64)?;
-                for (id, ty) in ms.iter() {
+                for (id, ty) in ms {
                     let mut name = Vec::from(id.as_bytes());
                     leb128_encode(&mut buf, name.len() as u64)?;
                     buf.append(&mut name);
@@ -314,15 +327,15 @@ impl TypeSerialize {
                 }
                 sleb128_encode(&mut buf, Opcode::Func as i64)?;
                 leb128_encode(&mut buf, func.args.len() as u64)?;
-                for ty in func.args.iter() {
+                for ty in &func.args {
                     self.encode(&mut buf, ty)?;
                 }
                 leb128_encode(&mut buf, func.rets.len() as u64)?;
-                for ty in func.rets.iter() {
+                for ty in &func.rets {
                     self.encode(&mut buf, ty)?;
                 }
                 leb128_encode(&mut buf, func.modes.len() as u64)?;
-                for m in func.modes.iter() {
+                for m in &func.modes {
                     use crate::types::FuncMode;
                     let m = match m {
                         FuncMode::Query => 1,
@@ -402,7 +415,7 @@ impl TypeSerialize {
 
         leb128_encode(&mut self.result, self.args.len() as u64)?;
         let mut ty_encode = Vec::new();
-        for t in self.args.iter() {
+        for t in &self.args {
             self.encode(&mut ty_encode, t)?;
         }
         self.result.append(&mut ty_encode);
diff --git a/rust/candid/src/types/arc.rs b/rust/candid/src/types/arc.rs
index 3d8214d9..9b24c46c 100644
--- a/rust/candid/src/types/arc.rs
+++ b/rust/candid/src/types/arc.rs
@@ -1,15 +1,14 @@
 //! This module provides functions to serialize and deserialize types
-//! under [std::sync::Arc] shared reference type.
+//! under [`std::sync::Arc`] shared reference type.
 //!
 //! # Examples
 //!
 //! ```
 //! use candid::{CandidType, Deserialize};
-//! use serde_bytes::ByteBuf;
 //! use std::sync::Arc;
 //!
 //! #[derive(CandidType, Deserialize, PartialEq)]
-//! struct ArcBytes(#[serde(with = "candid::arc")] Arc<ByteBuf>);
+//! struct ArcString(#[serde(with = "candid::arc")] Arc<String>);
 //! ```
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::sync::Arc;
diff --git a/rust/candid/src/types/impls.rs b/rust/candid/src/types/impls.rs
index 3caf1077..923ffc59 100644
--- a/rust/candid/src/types/impls.rs
+++ b/rust/candid/src/types/impls.rs
@@ -41,7 +41,7 @@ impl CandidType for i128 {
     where
         S: Serializer,
     {
-        serializer.serialize_int(&crate::Int::from(*self))
+        serializer.serialize_i128(*self)
     }
 }
 impl CandidType for u128 {
@@ -52,7 +52,7 @@ impl CandidType for u128 {
     where
         S: Serializer,
     {
-        serializer.serialize_nat(&crate::Nat::from(*self))
+        serializer.serialize_u128(*self)
     }
 }
 
@@ -134,12 +134,14 @@ where
         S: Serializer,
     {
         let mut ser = serializer.serialize_vec(self.len())?;
-        for e in self.iter() {
+        for e in self {
             Compound::serialize_element(&mut ser, &e)?;
         }
         Ok(())
     }
 }
+#[cfg_attr(docsrs, doc(cfg(feature = "serde_bytes")))]
+#[cfg(feature = "serde_bytes")]
 impl CandidType for serde_bytes::ByteBuf {
     fn _ty() -> Type {
         TypeInner::Vec(TypeInner::Nat8.into()).into()
@@ -151,6 +153,8 @@ impl CandidType for serde_bytes::ByteBuf {
         serializer.serialize_blob(self.as_slice())
     }
 }
+#[cfg_attr(docsrs, doc(cfg(feature = "serde_bytes")))]
+#[cfg(feature = "serde_bytes")]
 impl CandidType for serde_bytes::Bytes {
     fn _ty() -> Type {
         TypeInner::Vec(TypeInner::Nat8.into()).into()
@@ -241,7 +245,7 @@ impl<T: CandidType, const N: usize> CandidType for [T; N] {
         S: Serializer,
     {
         let mut ser = serializer.serialize_vec(N)?;
-        for e in self.iter() {
+        for e in self {
             Compound::serialize_element(&mut ser, &e)?;
         }
         Ok(())
diff --git a/rust/candid/src/types/internal.rs b/rust/candid/src/types/internal.rs
index 47676e07..5318827f 100644
--- a/rust/candid/src/types/internal.rs
+++ b/rust/candid/src/types/internal.rs
@@ -1,6 +1,5 @@
 use super::CandidType;
 use crate::idl_hash;
-use num_enum::TryFromPrimitive;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::fmt;
@@ -202,13 +201,11 @@ pub enum TypeInner {
 }
 impl std::ops::Deref for Type {
     type Target = TypeInner;
-    #[inline(always)]
     fn deref(&self) -> &TypeInner {
-        self.0.deref()
+        &self.0
     }
 }
 impl AsRef<TypeInner> for Type {
-    #[inline(always)]
     fn as_ref(&self) -> &TypeInner {
         self.0.as_ref()
     }
@@ -232,11 +229,25 @@ impl TypeInner {
             _ => false,
         }
     }
+    pub fn is_blob(&self, env: &crate::TypeEnv) -> bool {
+        match self {
+            TypeInner::Vec(t) => {
+                let Ok(t) = env.trace_type(t) else {
+                    return false;
+                };
+                matches!(*t, TypeInner::Nat8)
+            }
+            _ => false,
+        }
+    }
 }
 impl Type {
     pub fn is_tuple(&self) -> bool {
         self.as_ref().is_tuple()
     }
+    pub fn is_blob(&self, env: &crate::TypeEnv) -> bool {
+        self.as_ref().is_blob(env)
+    }
     pub fn subst(&self, tau: &std::collections::BTreeMap<String, String>) -> Self {
         use TypeInner::*;
         match self.as_ref() {
@@ -281,18 +292,28 @@ impl Type {
         .into()
     }
 }
+#[cfg(feature = "printer")]
 impl fmt::Display for Type {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", crate::bindings::candid::pp_ty(self).pretty(80))
+        write!(f, "{}", crate::pretty::candid::pp_ty(self).pretty(80))
     }
 }
+#[cfg(feature = "printer")]
 impl fmt::Display for TypeInner {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}",
-            crate::bindings::candid::pp_ty_inner(self).pretty(80)
-        )
+        write!(f, "{}", crate::pretty::candid::pp_ty_inner(self).pretty(80))
+    }
+}
+#[cfg(not(feature = "printer"))]
+impl fmt::Display for Type {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+#[cfg(not(feature = "printer"))]
+impl fmt::Display for TypeInner {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
     }
 }
 pub(crate) fn text_size(t: &Type, limit: i32) -> Result<i32, ()> {
@@ -314,11 +335,11 @@ pub(crate) fn text_size(t: &Type, limit: i32) -> Result<i32, ()> {
         Record(fs) | Variant(fs) => {
             let mut cnt = 0;
             let mut limit = limit;
-            for f in fs.iter() {
+            for f in fs {
                 let id_size = match f.id.as_ref() {
                     Label::Named(n) => n.len() as i32,
                     Label::Id(_) => 4,
-                    _ => 0,
+                    Label::Unnamed(_) => 0,
                 };
                 cnt += id_size + text_size(&f.ty, limit - id_size - 3)? + 3;
                 limit -= cnt;
@@ -329,11 +350,11 @@ pub(crate) fn text_size(t: &Type, limit: i32) -> Result<i32, ()> {
             let mode = if func.modes.is_empty() { 0 } else { 6 };
             let mut cnt = mode + 6;
             let mut limit = limit - cnt;
-            for t in func.args.iter() {
+            for t in &func.args {
                 cnt += text_size(t, limit)?;
                 limit -= cnt;
             }
-            for t in func.rets.iter() {
+            for t in &func.rets {
                 cnt += text_size(t, limit)?;
                 limit -= cnt;
             }
@@ -342,7 +363,7 @@ pub(crate) fn text_size(t: &Type, limit: i32) -> Result<i32, ()> {
         Service(ms) => {
             let mut cnt = 0;
             let mut limit = limit;
-            for (name, f) in ms.iter() {
+            for (name, f) in ms {
                 let len = name.len() as i32;
                 cnt += len + text_size(f, limit - len - 3)? + 3;
                 limit -= cnt;
@@ -368,9 +389,8 @@ pub enum Label {
 impl Label {
     pub fn get_id(&self) -> u32 {
         match *self {
-            Label::Id(n) => n,
+            Label::Id(n) | Label::Unnamed(n) => n,
             Label::Named(ref n) => idl_hash(n),
-            Label::Unnamed(n) => n,
         }
     }
 }
@@ -379,7 +399,7 @@ impl std::fmt::Display for Label {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Label::Id(n) | Label::Unnamed(n) => {
-                write!(f, "{}", super::number::pp_num_str(&n.to_string()))
+                write!(f, "{}", crate::utils::pp_num_str(&n.to_string()))
             }
             Label::Named(id) => write!(f, "{id}"),
         }
@@ -405,15 +425,23 @@ pub struct Field {
     pub id: SharedLabel,
     pub ty: Type,
 }
+#[cfg(feature = "printer")]
 impl fmt::Display for Field {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
             "{}",
-            crate::bindings::candid::pp_field(self, false).pretty(80)
+            crate::pretty::candid::pp_field(self, false).pretty(80)
         )
     }
 }
+#[cfg(not(feature = "printer"))]
+impl fmt::Display for Field {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
 #[macro_export]
 /// Construct a field type, which can be used in `TypeInner::Record` and `TypeInner::Variant`.
 ///
@@ -461,32 +489,26 @@ pub enum FuncMode {
     Query,
     CompositeQuery,
 }
-impl FuncMode {
-    pub(crate) fn to_doc(&self) -> pretty::RcDoc {
-        match self {
-            FuncMode::Oneway => pretty::RcDoc::text("oneway"),
-            FuncMode::Query => pretty::RcDoc::text("query"),
-            FuncMode::CompositeQuery => pretty::RcDoc::text("composite_query"),
-        }
-    }
-}
 #[derive(Debug, PartialEq, Hash, Eq, Clone)]
 pub struct Function {
     pub modes: Vec<FuncMode>,
     pub args: Vec<Type>,
     pub rets: Vec<Type>,
 }
+#[cfg(feature = "printer")]
 impl fmt::Display for Function {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}",
-            crate::bindings::candid::pp_function(self).pretty(80)
-        )
+        write!(f, "{}", crate::pretty::candid::pp_function(self).pretty(80))
+    }
+}
+#[cfg(not(feature = "printer"))]
+impl fmt::Display for Function {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
     }
 }
 impl Function {
-    /// Check a function is a query or composite_query method
+    /// Check a function is a `query` or `composite_query` method
     pub fn is_query(&self) -> bool {
         self.modes
             .iter()
@@ -526,9 +548,9 @@ macro_rules! service {
     }}
 }
 
-#[derive(Debug, PartialEq, TryFromPrimitive)]
+#[derive(Debug, PartialEq)]
 #[repr(i64)]
-pub(crate) enum Opcode {
+pub enum Opcode {
     Null = -1,
     Bool = -2,
     Nat = -3,
@@ -604,10 +626,10 @@ thread_local! {
     static ENV: RefCell<HashMap<TypeId, Type>> = RefCell::new(HashMap::new());
     // only used for TypeContainer
     static ID: RefCell<HashMap<Type, TypeId>> = RefCell::new(HashMap::new());
-    static NAME: RefCell<TypeName> = RefCell::new(Default::default());
+    static NAME: RefCell<TypeName> = RefCell::new(TypeName::default());
 }
 
-pub(crate) fn find_type(id: &TypeId) -> Option<Type> {
+pub fn find_type(id: &TypeId) -> Option<Type> {
     ENV.with(|e| e.borrow().get(id).cloned())
 }
 
@@ -618,9 +640,9 @@ pub(crate) fn show_env() {
 }
 
 pub(crate) fn env_add(id: TypeId, t: Type) {
-    ENV.with(|e| drop(e.borrow_mut().insert(id, t)));
+    ENV.with(|e| e.borrow_mut().insert(id, t));
 }
-pub(crate) fn env_clear() {
+pub fn env_clear() {
     ENV.with(|e| e.borrow_mut().clear());
 }
 
diff --git a/rust/candid/src/types/leb128.rs b/rust/candid/src/types/leb128.rs
new file mode 100644
index 00000000..a250a031
--- /dev/null
+++ b/rust/candid/src/types/leb128.rs
@@ -0,0 +1,100 @@
+use crate::error::{Error, Result};
+use std::io;
+
+// Code copied from https://github.com/gimli-rs/leb128/blob/master/src/lib.rs.
+// Changing the type from i64 to i128
+
+const CONTINUATION_BIT: u8 = 1 << 7;
+const SIGN_BIT: u8 = 1 << 6;
+
+pub fn encode_nat<W>(w: &mut W, mut val: u128) -> Result<()>
+where
+    W: io::Write + ?Sized,
+{
+    loop {
+        let mut byte = (val & 0x7fu128) as u8;
+        val >>= 7;
+        if val != 0 {
+            byte |= CONTINUATION_BIT;
+        }
+        let buf = [byte];
+        w.write_all(&buf)?;
+        if val == 0 {
+            return Ok(());
+        }
+    }
+}
+pub fn encode_int<W>(w: &mut W, mut val: i128) -> Result<()>
+where
+    W: io::Write + ?Sized,
+{
+    loop {
+        let mut byte = val as u8;
+        val >>= 6;
+        let done = val == 0 || val == -1;
+        if done {
+            byte &= !CONTINUATION_BIT;
+        } else {
+            val >>= 1;
+            byte |= CONTINUATION_BIT;
+        }
+        let buf = [byte];
+        w.write_all(&buf)?;
+        if done {
+            return Ok(());
+        }
+    }
+}
+pub fn decode_nat<R>(r: &mut R) -> Result<u128>
+where
+    R: io::Read + ?Sized,
+{
+    let mut result = 0;
+    let mut shift = 0;
+    loop {
+        let mut buf = [0];
+        r.read_exact(&mut buf)?;
+        if shift == 127 && buf[0] != 0x00 && buf[0] != 0x01 {
+            while buf[0] & CONTINUATION_BIT != 0 {
+                r.read_exact(&mut buf)?;
+            }
+            return Err(Error::msg("nat overflow"));
+        }
+        let low_bits = (buf[0] & !CONTINUATION_BIT) as u128;
+        result |= low_bits << shift;
+        if buf[0] & CONTINUATION_BIT == 0 {
+            return Ok(result);
+        }
+        shift += 7;
+    }
+}
+pub fn decode_int<R>(r: &mut R) -> Result<i128>
+where
+    R: io::Read + ?Sized,
+{
+    let mut result = 0;
+    let mut shift = 0;
+    let size = 128;
+    let mut byte;
+    loop {
+        let mut buf = [0];
+        r.read_exact(&mut buf)?;
+        byte = buf[0];
+        if shift == 127 && byte != 0x00 && byte != 0x7f {
+            while buf[0] & CONTINUATION_BIT != 0 {
+                r.read_exact(&mut buf)?;
+            }
+            return Err(Error::msg("int overflow"));
+        }
+        let low_bits = (byte & !CONTINUATION_BIT) as i128;
+        result |= low_bits << shift;
+        shift += 7;
+        if byte & CONTINUATION_BIT == 0 {
+            break;
+        }
+    }
+    if shift < size && (byte & SIGN_BIT) == SIGN_BIT {
+        result |= !0 << shift;
+    }
+    Ok(result)
+}
diff --git a/rust/candid/src/types/mod.rs b/rust/candid/src/types/mod.rs
index edcc3a09..f844ab72 100644
--- a/rust/candid/src/types/mod.rs
+++ b/rust/candid/src/types/mod.rs
@@ -10,6 +10,8 @@ mod impls;
 pub mod internal;
 pub mod subtype;
 pub mod type_env;
+#[cfg_attr(docsrs, doc(cfg(feature = "value")))]
+#[cfg(feature = "value")]
 pub mod value;
 
 pub use self::internal::{
@@ -17,6 +19,8 @@ pub use self::internal::{
 };
 pub use type_env::TypeEnv;
 
+pub mod leb128;
+#[cfg(feature = "bignum")]
 pub mod number;
 pub mod principal;
 pub mod reference;
@@ -56,8 +60,14 @@ pub trait Serializer: Sized {
     type Error: Error;
     type Compound: Compound<Error = Self::Error>;
     fn serialize_bool(self, v: bool) -> Result<(), Self::Error>;
+    #[cfg_attr(docsrs, doc(cfg(feature = "bignum")))]
+    #[cfg(feature = "bignum")]
     fn serialize_int(self, v: &crate::Int) -> Result<(), Self::Error>;
+    fn serialize_i128(self, v: i128) -> Result<(), Self::Error>;
+    #[cfg_attr(docsrs, doc(cfg(feature = "bignum")))]
+    #[cfg(feature = "bignum")]
     fn serialize_nat(self, v: &crate::Nat) -> Result<(), Self::Error>;
+    fn serialize_u128(self, v: u128) -> Result<(), Self::Error>;
     fn serialize_nat8(self, v: u8) -> Result<(), Self::Error>;
     fn serialize_nat16(self, v: u16) -> Result<(), Self::Error>;
     fn serialize_nat32(self, v: u32) -> Result<(), Self::Error>;
diff --git a/rust/candid/src/types/number.rs b/rust/candid/src/types/number.rs
index ef550bea..5cdaa864 100644
--- a/rust/candid/src/types/number.rs
+++ b/rust/candid/src/types/number.rs
@@ -1,7 +1,7 @@
 //! Data structure for Candid type Int, Nat, supporting big integer with LEB128 encoding.
 
 use super::{CandidType, Serializer, Type, TypeInner};
-use crate::Error;
+use crate::{utils::pp_num_str, Error};
 use num_bigint::{BigInt, BigUint};
 use serde::{
     de::{self, Deserialize, SeqAccess, Visitor},
@@ -16,21 +16,18 @@ pub struct Int(pub BigInt);
 pub struct Nat(pub BigUint);
 
 impl From<BigInt> for Int {
-    #[inline(always)]
     fn from(i: BigInt) -> Self {
         Self(i)
     }
 }
 
 impl From<BigUint> for Nat {
-    #[inline(always)]
     fn from(i: BigUint) -> Self {
         Self(i)
     }
 }
 
 impl From<Nat> for Int {
-    #[inline(always)]
     fn from(n: Nat) -> Self {
         let i: BigInt = n.0.into();
         i.into()
@@ -38,21 +35,18 @@ impl From<Nat> for Int {
 }
 
 impl From<Int> for BigInt {
-    #[inline(always)]
     fn from(i: Int) -> Self {
         i.0
     }
 }
 
 impl From<Nat> for BigUint {
-    #[inline(always)]
     fn from(i: Nat) -> Self {
         i.0
     }
 }
 
 impl From<Nat> for BigInt {
-    #[inline(always)]
     fn from(i: Nat) -> Self {
         i.0.into()
     }
@@ -88,20 +82,6 @@ impl std::str::FromStr for Nat {
     }
 }
 
-pub(crate) fn pp_num_str(s: &str) -> String {
-    let mut groups = Vec::new();
-    for chunk in s.as_bytes().rchunks(3) {
-        let str = String::from_utf8_lossy(chunk);
-        groups.push(str);
-    }
-    groups.reverse();
-    if "-" == groups.first().unwrap() {
-        "-".to_string() + &groups[1..].join("_")
-    } else {
-        groups.join("_")
-    }
-}
-
 impl fmt::Display for Int {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let s = self.0.to_str_radix(10);
@@ -162,9 +142,9 @@ impl<'de> Deserialize<'de> for Int {
                     .map_err(|_| de::Error::custom(format!("{v:?} is not int")))
             }
             fn visit_byte_buf<E: de::Error>(self, v: Vec<u8>) -> Result<Int, E> {
-                Ok(Int(match v[0] {
-                    0 => BigInt::from_signed_bytes_le(&v[1..]),
-                    1 => BigInt::from_biguint(
+                Ok(Int(match v.first() {
+                    Some(0) => BigInt::from_signed_bytes_le(&v[1..]),
+                    Some(1) => BigInt::from_biguint(
                         num_bigint::Sign::Plus,
                         BigUint::from_bytes_le(&v[1..]),
                     ),
@@ -366,7 +346,7 @@ macro_rules! define_op {
 
             #[inline]
             fn $method(self, other: $res) -> $res {
-                $imp::$method(other.0, &self).into()
+                $imp::$method(&self, other.0).into()
             }
         }
     };
@@ -480,97 +460,6 @@ define_op_0_assign!(impl MulAssign<Int> for Int, mul_assign);
 define_op_0_assign!(impl DivAssign<Int> for Int, div_assign);
 define_op_0_assign!(impl RemAssign<Int> for Int, rem_assign);
 
-// Special cases for literals which are i32, for Nat which isn't support in BigUint,
-// so we add a conversion to u32.
-impl From<i32> for Nat {
-    #[inline]
-    fn from(v: i32) -> Self {
-        Self::from(v as u32)
-    }
-}
-impl PartialEq<i32> for Nat {
-    #[inline]
-    #[must_use]
-    fn eq(&self, v: &i32) -> bool {
-        self.0.eq(&(*v as u32).into())
-    }
-}
-
-impl std::ops::Add<i32> for Nat {
-    type Output = Self;
-
-    #[inline]
-    fn add(self, other: i32) -> Self {
-        (self.0 + (other as u32)).into()
-    }
-}
-impl std::ops::AddAssign<i32> for Nat {
-    #[inline]
-    fn add_assign(&mut self, other: i32) {
-        self.0 += other as u32
-    }
-}
-
-impl std::ops::Sub<i32> for Nat {
-    type Output = Self;
-
-    #[inline]
-    fn sub(self, other: i32) -> Self {
-        (self.0 - (other as u32)).into()
-    }
-}
-impl std::ops::SubAssign<i32> for Nat {
-    #[inline]
-    fn sub_assign(&mut self, other: i32) {
-        self.0 -= other as u32
-    }
-}
-
-impl std::ops::Mul<i32> for Nat {
-    type Output = Self;
-
-    #[inline]
-    fn mul(self, other: i32) -> Self {
-        (self.0 * (other as u32)).into()
-    }
-}
-impl std::ops::MulAssign<i32> for Nat {
-    #[inline]
-    fn mul_assign(&mut self, other: i32) {
-        self.0 *= other as u32
-    }
-}
-
-impl std::ops::Div<i32> for Nat {
-    type Output = Self;
-
-    #[inline]
-    fn div(self, other: i32) -> Self {
-        (self.0 / (other as u32)).into()
-    }
-}
-impl std::ops::DivAssign<i32> for Nat {
-    #[inline]
-    fn div_assign(&mut self, other: i32) {
-        self.0 /= other as u32
-    }
-}
-
-impl std::ops::Rem<i32> for Nat {
-    type Output = Self;
-
-    #[inline]
-    fn rem(self, other: i32) -> Self {
-        (self.0 % (other as u32)).into()
-    }
-}
-impl std::ops::RemAssign<i32> for Nat {
-    #[inline]
-    fn rem_assign(&mut self, other: i32) {
-        self.0 %= other as u32
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/rust/candid/src/types/principal.rs b/rust/candid/src/types/principal.rs
index f5c8d776..7cca8fbd 100644
--- a/rust/candid/src/types/principal.rs
+++ b/rust/candid/src/types/principal.rs
@@ -1,95 +1,6 @@
 use super::{CandidType, Serializer, Type, TypeInner};
-use serde::{Deserialize, Serialize};
-use sha2::{Digest, Sha224};
-use std::convert::TryFrom;
-use std::fmt::Write;
-use thiserror::Error;
 
-/// An error happened while encoding, decoding or serializing a [`Principal`].
-#[derive(Error, Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-pub enum PrincipalError {
-    #[error("Bytes is longer than 29 bytes.")]
-    BytesTooLong(),
-
-    #[error("Text must be in valid Base32 encoding.")]
-    InvalidBase32(),
-
-    #[error("Text is too short.")]
-    TextTooShort(),
-
-    #[error("Text is too long.")]
-    TextTooLong(),
-
-    #[error("CRC32 check sequence doesn't match with calculated from Principal bytes.")]
-    CheckSequenceNotMatch(),
-
-    #[error(r#"Text should be separated by - (dash) every 5 characters: expected "{0}""#)]
-    AbnormalGrouped(Principal),
-}
-
-/// Generic ID on Internet Computer.
-///
-/// Principals are generic identifiers for canisters, users
-/// and possibly other concepts in the future.
-/// As far as most uses of the IC are concerned they are
-/// opaque binary blobs with a length between 0 and 29 bytes,
-/// and there is intentionally no mechanism to tell canister ids and user ids apart.
-///
-/// Note a principal is not necessarily tied with a public key-pair,
-/// yet we need at least a key-pair of a related principal to sign
-/// requests.
-///
-/// A Principal can be serialized to a byte array ([`Vec<u8>`]) or a text
-/// representation, but the inner structure of the byte representation
-/// is kept private.
-///
-/// Example of using a Principal object:
-/// ```
-/// # use candid::Principal;
-/// let text = "aaaaa-aa";  // The management canister ID.
-/// let principal = Principal::from_text(text).expect("Could not decode the principal.");
-/// assert_eq!(principal.as_slice(), &[] as &[u8]);
-/// assert_eq!(principal.to_text(), text);
-/// ```
-///
-/// Similarly, serialization using serde has two versions:
-/// serilizing to a byte bufer for non-human readable serializer, and a string version for human
-/// readable serializers.
-///
-/// ```
-/// # use candid::Principal;
-/// use serde::{Deserialize, Serialize};
-/// use std::str::FromStr;
-///
-/// #[derive(Serialize)]
-/// struct Data {
-///     id: Principal,
-/// }
-///
-/// let id = Principal::from_str("2chl6-4hpzw-vqaaa-aaaaa-c").unwrap();
-///
-/// // JSON is human readable, so this will serialize to a textual
-/// // representation of the Principal.
-/// assert_eq!(
-///     serde_json::to_string(&Data { id: id.clone() }).unwrap(),
-///     r#"{"id":"2chl6-4hpzw-vqaaa-aaaaa-c"}"#
-/// );
-///
-/// // CBOR is not human readable, so will serialize to bytes.
-/// assert_eq!(
-///     serde_cbor::to_vec(&Data { id: id.clone() }).unwrap(),
-///     &[161, 98, 105, 100, 73, 239, 205, 171, 0, 0, 0, 0, 0, 1],
-/// );
-/// ```
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Principal {
-    /// Length.
-    len: u8,
-
-    /// The content buffer. When returning slices this should always be sized according to
-    /// `len`.
-    bytes: [u8; Self::MAX_LENGTH_IN_BYTES],
-}
+pub use ic_principal::{Principal, PrincipalError};
 
 impl CandidType for Principal {
     fn _ty() -> Type {
@@ -102,266 +13,3 @@ impl CandidType for Principal {
         serializer.serialize_principal(self.as_slice())
     }
 }
-
-impl Principal {
-    const MAX_LENGTH_IN_BYTES: usize = 29;
-    const CRC_LENGTH_IN_BYTES: usize = 4;
-
-    const SELF_AUTHENTICATING_TAG: u8 = 2;
-    const ANONYMOUS_TAG: u8 = 4;
-
-    /// Construct a [`Principal`] of the IC management canister
-    pub const fn management_canister() -> Self {
-        Self {
-            len: 0,
-            bytes: [0; Self::MAX_LENGTH_IN_BYTES],
-        }
-    }
-
-    /// Construct a self-authenticating ID from public key
-    pub fn self_authenticating<P: AsRef<[u8]>>(public_key: P) -> Self {
-        let public_key = public_key.as_ref();
-        let hash = Sha224::digest(public_key);
-        let mut bytes = [0; Self::MAX_LENGTH_IN_BYTES];
-        bytes[..Self::MAX_LENGTH_IN_BYTES - 1].copy_from_slice(hash.as_slice());
-        bytes[Self::MAX_LENGTH_IN_BYTES - 1] = Self::SELF_AUTHENTICATING_TAG;
-
-        Self {
-            len: Self::MAX_LENGTH_IN_BYTES as u8,
-            bytes,
-        }
-    }
-
-    /// Construct an anonymous ID.
-    pub const fn anonymous() -> Self {
-        let mut bytes = [0; Self::MAX_LENGTH_IN_BYTES];
-        bytes[0] = Self::ANONYMOUS_TAG;
-        Self { len: 1, bytes }
-    }
-
-    /// Construct a [`Principal`] from a slice of bytes.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the slice is longer than 29 bytes.
-    pub const fn from_slice(slice: &[u8]) -> Self {
-        match Self::try_from_slice(slice) {
-            Ok(v) => v,
-            _ => panic!("slice length exceeds capacity"),
-        }
-    }
-
-    /// Construct a [`Principal`] from a slice of bytes.
-    pub const fn try_from_slice(slice: &[u8]) -> Result<Self, PrincipalError> {
-        const MAX_LENGTH_IN_BYTES: usize = Principal::MAX_LENGTH_IN_BYTES;
-        match slice.len() {
-            len @ 0..=MAX_LENGTH_IN_BYTES => {
-                let mut bytes = [0; MAX_LENGTH_IN_BYTES];
-                let mut i = 0;
-                while i < len {
-                    bytes[i] = slice[i];
-                    i += 1;
-                }
-                Ok(Self {
-                    len: len as u8,
-                    bytes,
-                })
-            }
-            _ => Err(PrincipalError::BytesTooLong()),
-        }
-    }
-
-    /// Parse a [`Principal`] from text representation.
-    pub fn from_text<S: AsRef<str>>(text: S) -> Result<Self, PrincipalError> {
-        // Strategy: Parse very liberally, then pretty-print and compare output
-        // This is both simpler and yields better error messages
-
-        let mut s = text.as_ref().to_string();
-        s.make_ascii_uppercase();
-        s.retain(|c| c != '-');
-        match data_encoding::BASE32_NOPAD.decode(s.as_bytes()) {
-            Ok(bytes) => {
-                if bytes.len() < Self::CRC_LENGTH_IN_BYTES {
-                    return Err(PrincipalError::TextTooShort());
-                }
-
-                let crc_bytes = &bytes[..Self::CRC_LENGTH_IN_BYTES];
-                let data_bytes = &bytes[Self::CRC_LENGTH_IN_BYTES..];
-                if data_bytes.len() > Self::MAX_LENGTH_IN_BYTES {
-                    return Err(PrincipalError::TextTooLong());
-                }
-
-                if crc32fast::hash(data_bytes).to_be_bytes() != crc_bytes {
-                    return Err(PrincipalError::CheckSequenceNotMatch());
-                }
-
-                // Already checked data_bytes.len() <= MAX_LENGTH_IN_BYTES
-                // safe to unwrap here
-                let result = Self::try_from_slice(data_bytes).unwrap();
-                let expected = format!("{result}");
-
-                // In the Spec:
-                // The textual representation is conventionally printed with lower case letters,
-                // but parsed case-insensitively.
-                if text.as_ref().to_ascii_lowercase() != expected {
-                    return Err(PrincipalError::AbnormalGrouped(result));
-                }
-                Ok(result)
-            }
-            _ => Err(PrincipalError::InvalidBase32()),
-        }
-    }
-
-    /// Convert [`Principal`] to text representation.
-    pub fn to_text(&self) -> String {
-        format!("{self}")
-    }
-
-    /// Return the [`Principal`]'s underlying slice of bytes.
-    #[inline]
-    pub fn as_slice(&self) -> &[u8] {
-        &self.bytes[..self.len as usize]
-    }
-}
-
-impl std::fmt::Display for Principal {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let blob: &[u8] = self.as_slice();
-
-        // calc checksum
-        let checksum = crc32fast::hash(blob);
-
-        // combine blobs
-        let mut bytes = vec![];
-        bytes.extend_from_slice(&checksum.to_be_bytes());
-        bytes.extend_from_slice(blob);
-
-        // base32
-        let mut s = data_encoding::BASE32_NOPAD.encode(&bytes);
-        s.make_ascii_lowercase();
-
-        // write out string with dashes
-        let mut s = s.as_str();
-        while s.len() > 5 {
-            f.write_str(&s[..5])?;
-            f.write_char('-')?;
-            s = &s[5..];
-        }
-        f.write_str(s)
-    }
-}
-
-impl std::str::FromStr for Principal {
-    type Err = PrincipalError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Principal::from_text(s)
-    }
-}
-
-impl TryFrom<&str> for Principal {
-    type Error = PrincipalError;
-
-    fn try_from(s: &str) -> Result<Self, Self::Error> {
-        Principal::from_text(s)
-    }
-}
-
-impl TryFrom<Vec<u8>> for Principal {
-    type Error = PrincipalError;
-
-    fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
-        Self::try_from(bytes.as_slice())
-    }
-}
-
-impl TryFrom<&Vec<u8>> for Principal {
-    type Error = PrincipalError;
-
-    fn try_from(bytes: &Vec<u8>) -> Result<Self, Self::Error> {
-        Self::try_from(bytes.as_slice())
-    }
-}
-
-impl TryFrom<&[u8]> for Principal {
-    type Error = PrincipalError;
-
-    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
-        Self::try_from_slice(bytes)
-    }
-}
-
-impl AsRef<[u8]> for Principal {
-    fn as_ref(&self) -> &[u8] {
-        self.as_slice()
-    }
-}
-
-// Serialization
-impl serde::Serialize for Principal {
-    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        if serializer.is_human_readable() {
-            self.to_text().serialize(serializer)
-        } else {
-            serializer.serialize_bytes(self.as_slice())
-        }
-    }
-}
-
-// Deserialization
-mod deserialize {
-    use super::Principal;
-    use std::convert::TryFrom;
-
-    // Simple visitor for deserialization from bytes. We don't support other number types
-    // as there's no need for it.
-    pub(super) struct PrincipalVisitor;
-
-    impl<'de> serde::de::Visitor<'de> for PrincipalVisitor {
-        type Value = super::Principal;
-
-        fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            formatter.write_str("bytes or string")
-        }
-
-        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-        where
-            E: serde::de::Error,
-        {
-            Principal::from_text(v).map_err(E::custom)
-        }
-
-        fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-        where
-            E: serde::de::Error,
-        {
-            Principal::try_from(value).map_err(E::custom)
-        }
-        /// This visitor should only be used by the Candid crate.
-        fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-        where
-            E: serde::de::Error,
-        {
-            if v.is_empty() || v[0] != 2u8 {
-                Err(E::custom("Not called by Candid"))
-            } else {
-                Principal::try_from(&v[1..]).map_err(E::custom)
-            }
-        }
-    }
-}
-
-impl<'de> serde::Deserialize<'de> for Principal {
-    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Principal, D::Error> {
-        use serde::de::Error;
-        if deserializer.is_human_readable() {
-            deserializer
-                .deserialize_str(deserialize::PrincipalVisitor)
-                .map_err(D::Error::custom)
-        } else {
-            deserializer
-                .deserialize_bytes(deserialize::PrincipalVisitor)
-                .map_err(D::Error::custom)
-        }
-    }
-}
diff --git a/rust/candid/src/types/rc.rs b/rust/candid/src/types/rc.rs
index 70d48970..ed6313ec 100644
--- a/rust/candid/src/types/rc.rs
+++ b/rust/candid/src/types/rc.rs
@@ -1,15 +1,14 @@
 //! This module provides functions to serialize and deserialize types
-//! under [std::rc::Rc] shared reference type.
+//! under [`std::rc::Rc`] shared reference type.
 //!
 //! # Examples
 //!
 //! ```
 //! use candid::{CandidType, Deserialize};
-//! use serde_bytes::ByteBuf;
 //! use std::rc::Rc;
 //!
 //! #[derive(CandidType, Deserialize, PartialEq)]
-//! struct RcBytes(#[serde(with = "candid::rc")] Rc<ByteBuf>);
+//! struct RcString(#[serde(with = "candid::rc")] Rc<String>);
 //! ```
 
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
diff --git a/rust/candid/src/types/subtype.rs b/rust/candid/src/types/subtype.rs
index 4101cdbc..29235ec2 100644
--- a/rust/candid/src/types/subtype.rs
+++ b/rust/candid/src/types/subtype.rs
@@ -1,5 +1,4 @@
 use super::internal::{find_type, Field, Label, Type, TypeInner};
-use crate::bindings::candid::pp_args;
 use crate::types::TypeEnv;
 use crate::{Error, Result};
 use anyhow::Context;
@@ -7,8 +6,35 @@ use std::collections::{HashMap, HashSet};
 
 pub type Gamma = HashSet<(Type, Type)>;
 
+/// Error reporting style for the special opt rule
+#[derive(Debug, Copy, Clone)]
+pub enum OptReport {
+    Silence,
+    Warning,
+    Error,
+}
 /// Check if t1 <: t2
 pub fn subtype(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result<()> {
+    subtype_(OptReport::Warning, gamma, env, t1, t2)
+}
+/// Check if t1 <: t2, and report the special opt rule as `Slience`, `Warning` or `Error`.
+pub fn subtype_with_config(
+    report: OptReport,
+    gamma: &mut Gamma,
+    env: &TypeEnv,
+    t1: &Type,
+    t2: &Type,
+) -> Result<()> {
+    subtype_(report, gamma, env, t1, t2)
+}
+
+fn subtype_(
+    report: OptReport,
+    gamma: &mut Gamma,
+    env: &TypeEnv,
+    t1: &Type,
+    t2: &Type,
+) -> Result<()> {
     use TypeInner::*;
     if t1 == t2 {
         return Ok(());
@@ -18,10 +44,10 @@ pub fn subtype(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result
             return Ok(());
         }
         let res = match (t1.as_ref(), t2.as_ref()) {
-            (Var(id), _) => subtype(gamma, env, env.rec_find_type(id).unwrap(), t2),
-            (_, Var(id)) => subtype(gamma, env, t1, env.rec_find_type(id).unwrap()),
-            (Knot(id), _) => subtype(gamma, env, &find_type(id).unwrap(), t2),
-            (_, Knot(id)) => subtype(gamma, env, t1, &find_type(id).unwrap()),
+            (Var(id), _) => subtype_(report, gamma, env, env.rec_find_type(id).unwrap(), t2),
+            (_, Var(id)) => subtype_(report, gamma, env, t1, env.rec_find_type(id).unwrap()),
+            (Knot(id), _) => subtype_(report, gamma, env, &find_type(id).unwrap(), t2),
+            (_, Knot(id)) => subtype_(report, gamma, env, t1, &find_type(id).unwrap()),
             (_, _) => unreachable!(),
         };
         if res.is_err() {
@@ -33,25 +59,29 @@ pub fn subtype(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result
         (_, Reserved) => Ok(()),
         (Empty, _) => Ok(()),
         (Nat, Int) => Ok(()),
-        (Vec(ty1), Vec(ty2)) => subtype(gamma, env, ty1, ty2),
+        (Vec(ty1), Vec(ty2)) => subtype_(report, gamma, env, ty1, ty2),
         (Null, Opt(_)) => Ok(()),
-        (Opt(ty1), Opt(ty2)) if subtype(gamma, env, ty1, ty2).is_ok() => Ok(()),
+        (Opt(ty1), Opt(ty2)) if subtype_(report, gamma, env, ty1, ty2).is_ok() => Ok(()),
         (_, Opt(ty2))
-            if subtype(gamma, env, t1, ty2).is_ok()
+            if subtype_(report, gamma, env, t1, ty2).is_ok()
                 && !matches!(env.trace_type(ty2)?.as_ref(), Null | Reserved | Opt(_)) =>
         {
             Ok(())
         }
         (_, Opt(_)) => {
-            #[cfg(not(feature = "mute_warnings"))]
-            eprintln!("FIX ME! {t1} <: {t2} via special opt rule.\nThis means the sender and receiver type has diverged, and can cause data loss.");
+            let msg = format!("FIX ME! {t1} <: {t2} via special opt rule.\nThis means the sender and receiver type has diverged, and can cause data loss.");
+            match report {
+                OptReport::Silence => (),
+                OptReport::Warning => eprintln!("{msg}"),
+                OptReport::Error => return Err(Error::msg(msg)),
+            };
             Ok(())
         }
         (Record(fs1), Record(fs2)) => {
             let fields: HashMap<_, _> = fs1.iter().map(|Field { id, ty }| (id, ty)).collect();
-            for Field { id, ty: ty2 } in fs2.iter() {
+            for Field { id, ty: ty2 } in fs2 {
                 match fields.get(id) {
-                    Some(ty1) => subtype(gamma, env, ty1, ty2).with_context(|| {
+                    Some(ty1) => subtype_(report, gamma, env, ty1, ty2).with_context(|| {
                         format!("Record field {id}: {ty1} is not a subtype of {ty2}")
                     })?,
                     None => {
@@ -65,10 +95,10 @@ pub fn subtype(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result
         }
         (Variant(fs1), Variant(fs2)) => {
             let fields: HashMap<_, _> = fs2.iter().map(|Field { id, ty }| (id, ty)).collect();
-            for Field { id, ty: ty1 } in fs1.iter() {
+            for Field { id, ty: ty1 } in fs1 {
                 match fields.get(id) {
-                    Some(ty2) => subtype(gamma, env, ty1, ty2).with_context(|| {
-                        format!("Variant field {id}: {ty1} is not a subtype of {ty2}")
+                    Some(ty2) => subtype_(report, gamma, env, ty1, ty2).with_context(|| {
+                        format!("Variant field {id}: {ty1} is not a subtype_ of {ty2}")
                     })?,
                     None => {
                         return Err(Error::msg(format!(
@@ -81,9 +111,9 @@ pub fn subtype(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result
         }
         (Service(ms1), Service(ms2)) => {
             let meths: HashMap<_, _> = ms1.iter().map(|(name, ty)| (name, ty)).collect();
-            for (name, ty2) in ms2.iter() {
+            for (name, ty2) in ms2 {
                 match meths.get(name) {
-                    Some(ty1) => subtype(gamma, env, ty1, ty2).with_context(|| {
+                    Some(ty1) => subtype_(report, gamma, env, ty1, ty2).with_context(|| {
                         format!("Method {name}: {ty1} is not a subtype of {ty2}")
                     })?,
                     None => {
@@ -103,13 +133,15 @@ pub fn subtype(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result
             let args2 = to_tuple(&f2.args);
             let rets1 = to_tuple(&f1.rets);
             let rets2 = to_tuple(&f2.rets);
-            subtype(gamma, env, &args2, &args1).context("Subtype fails at function input type")?;
-            subtype(gamma, env, &rets1, &rets2).context("Subtype fails at function return type")?;
+            subtype_(report, gamma, env, &args2, &args1)
+                .context("Subtype fails at function input type")?;
+            subtype_(report, gamma, env, &rets1, &rets2)
+                .context("Subtype fails at function return type")?;
             Ok(())
         }
         // This only works in the first order case, but service constructor only appears at the top level according to the spec.
-        (Class(_, t), _) => subtype(gamma, env, t, t2),
-        (_, Class(_, t)) => subtype(gamma, env, t1, t),
+        (Class(_, t), _) => subtype_(report, gamma, env, t, t2),
+        (_, Class(_, t)) => subtype_(report, gamma, env, t1, t),
         (Unknown, _) => unreachable!(),
         (_, Unknown) => unreachable!(),
         (_, _) => Err(Error::msg(format!("{t1} is not a subtype of {t2}"))),
@@ -193,8 +225,8 @@ pub fn equal(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result<(
             let init_2 = to_tuple(init2);
             equal(gamma, env, &init_1, &init_2).context(format!(
                 "Mismatch in init args: {} and {}",
-                pp_args(init1).pretty(80),
-                pp_args(init2).pretty(80)
+                pp_args(init1),
+                pp_args(init2)
             ))?;
             equal(gamma, env, ty1, ty2)
         }
@@ -244,3 +276,19 @@ fn to_tuple(args: &[Type]) -> Type {
     )
     .into()
 }
+#[cfg(not(feature = "printer"))]
+fn pp_args(args: &[crate::types::Type]) -> String {
+    use std::fmt::Write;
+    let mut s = String::new();
+    write!(&mut s, "(").unwrap();
+    for arg in args.iter() {
+        write!(&mut s, "{:?}, ", arg).unwrap();
+    }
+    write!(&mut s, ")").unwrap();
+    s
+}
+#[cfg(feature = "printer")]
+fn pp_args(args: &[crate::types::Type]) -> String {
+    use crate::pretty::candid::pp_args;
+    pp_args(args).pretty(80).to_string()
+}
diff --git a/rust/candid/src/types/type_env.rs b/rust/candid/src/types/type_env.rs
index 439ee600..a5725df9 100644
--- a/rust/candid/src/types/type_env.rs
+++ b/rust/candid/src/types/type_env.rs
@@ -10,7 +10,7 @@ impl TypeEnv {
         TypeEnv(BTreeMap::new())
     }
     pub fn merge<'a>(&'a mut self, env: &TypeEnv) -> Result<&'a mut Self> {
-        for (k, v) in env.0.iter() {
+        for (k, v) in &env.0 {
             let entry = self.0.entry(k.to_string()).or_insert_with(|| v.clone());
             if *entry != *v {
                 return Err(Error::msg("inconsistent binding"));
@@ -25,7 +25,7 @@ impl TypeEnv {
             .filter(|k| self.0.contains_key(*k))
             .map(|k| (k.clone(), format!("{k}/1")))
             .collect();
-        for (k, t) in env.0.into_iter() {
+        for (k, t) in env.0 {
             let t = t.subst(&tau);
             if let Some(new_key) = tau.get(&k) {
                 self.0.insert(new_key.clone(), t);
@@ -73,7 +73,7 @@ impl TypeEnv {
         }
     }
     pub fn get_method<'a>(&'a self, t: &'a Type, id: &'a str) -> Result<&'a Function> {
-        for (meth, ty) in self.as_service(t)?.iter() {
+        for (meth, ty) in self.as_service(t)? {
             if meth == id {
                 return self.as_func(ty);
             }
@@ -91,7 +91,7 @@ impl TypeEnv {
         }
         match t.as_ref() {
             TypeInner::Record(fs) => {
-                for f in fs.iter() {
+                for f in fs {
                     self.go(seen, res, &f.ty)?;
                 }
             }
@@ -110,7 +110,7 @@ impl TypeEnv {
     }
     fn check_empty(&self) -> Result<BTreeSet<&str>> {
         let mut res = BTreeSet::new();
-        for (name, t) in self.0.iter() {
+        for (name, t) in &self.0 {
             let mut seen: BTreeSet<&str> = BTreeSet::new();
             let mut local_res = BTreeSet::new();
             seen.insert(name);
@@ -120,8 +120,12 @@ impl TypeEnv {
         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() {
+        let ids: Vec<_> = self
+            .check_empty()?
+            .iter()
+            .map(|x| (*x).to_string())
+            .collect();
+        for id in ids {
             self.0.insert(id, TypeInner::Empty.into());
         }
         Ok(())
@@ -129,7 +133,7 @@ impl TypeEnv {
 }
 impl std::fmt::Display for TypeEnv {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        for (k, v) in self.0.iter() {
+        for (k, v) in &self.0 {
             writeln!(f, "type {k} = {v}")?;
         }
         Ok(())
diff --git a/rust/candid/src/types/value.rs b/rust/candid/src/types/value.rs
index a2676218..8c6cef0b 100644
--- a/rust/candid/src/types/value.rs
+++ b/rust/candid/src/types/value.rs
@@ -18,6 +18,7 @@ pub enum IDLValue {
     Vec(Vec<IDLValue>),
     Record(Vec<IDLField>),
     Variant(VariantValue),
+    Blob(Vec<u8>),
     Principal(crate::Principal),
     Service(crate::Principal),
     Func(crate::Principal, String),
@@ -134,10 +135,6 @@ impl IDLValue {
     /// 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> {
-        #[cfg(not(feature = "parser"))]
-        if from_parser {
-            panic!("Please enable \"parser\" feature");
-        }
         Ok(match (self, t.as_ref()) {
             (_, TypeInner::Var(id)) => {
                 let ty = env.rec_find_type(id)?;
@@ -193,6 +190,17 @@ impl IDLValue {
             }
             // fallback
             (_, TypeInner::Opt(_)) if !from_parser => IDLValue::None,
+            (IDLValue::Blob(blob), ty) if ty.is_blob(env) => IDLValue::Blob(blob.to_vec()),
+            (IDLValue::Vec(vec), ty) if ty.is_blob(env) => {
+                let blob = vec
+                    .iter()
+                    .filter_map(|x| match *x {
+                        IDLValue::Nat8(n) => Some(n),
+                        _ => None,
+                    })
+                    .collect();
+                IDLValue::Blob(blob)
+            }
             (IDLValue::Vec(vec), TypeInner::Vec(ty)) => {
                 let mut res = Vec::new();
                 for e in vec.iter() {
@@ -239,27 +247,23 @@ impl IDLValue {
             (IDLValue::Principal(id), TypeInner::Principal) => IDLValue::Principal(*id),
             (IDLValue::Service(_), TypeInner::Service(_)) => self.clone(),
             (IDLValue::Func(_, _), TypeInner::Func(_)) => self.clone(),
-            #[cfg(feature = "parser")]
-            (IDLValue::Number(str), _) if from_parser => {
-                use crate::parser::token::error;
-                match t.as_ref() {
-                    TypeInner::Int => IDLValue::Int(str.parse::<Int>()?),
-                    TypeInner::Nat => IDLValue::Nat(str.parse::<Nat>()?),
-                    TypeInner::Nat8 => IDLValue::Nat8(str.parse::<u8>().map_err(error)?),
-                    TypeInner::Nat16 => IDLValue::Nat16(str.parse::<u16>().map_err(error)?),
-                    TypeInner::Nat32 => IDLValue::Nat32(str.parse::<u32>().map_err(error)?),
-                    TypeInner::Nat64 => IDLValue::Nat64(str.parse::<u64>().map_err(error)?),
-                    TypeInner::Int8 => IDLValue::Int8(str.parse::<i8>().map_err(error)?),
-                    TypeInner::Int16 => IDLValue::Int16(str.parse::<i16>().map_err(error)?),
-                    TypeInner::Int32 => IDLValue::Int32(str.parse::<i32>().map_err(error)?),
-                    TypeInner::Int64 => IDLValue::Int64(str.parse::<i64>().map_err(error)?),
-                    _ => {
-                        return Err(Error::msg(format!(
-                            "type mismatch: {self} can not be of type {t}"
-                        )))
-                    }
+            (IDLValue::Number(str), _) if from_parser => match t.as_ref() {
+                TypeInner::Int => IDLValue::Int(str.parse::<Int>()?),
+                TypeInner::Nat => IDLValue::Nat(str.parse::<Nat>()?),
+                TypeInner::Nat8 => IDLValue::Nat8(str.parse::<u8>()?),
+                TypeInner::Nat16 => IDLValue::Nat16(str.parse::<u16>()?),
+                TypeInner::Nat32 => IDLValue::Nat32(str.parse::<u32>()?),
+                TypeInner::Nat64 => IDLValue::Nat64(str.parse::<u64>()?),
+                TypeInner::Int8 => IDLValue::Int8(str.parse::<i8>()?),
+                TypeInner::Int16 => IDLValue::Int16(str.parse::<i16>()?),
+                TypeInner::Int32 => IDLValue::Int32(str.parse::<i32>()?),
+                TypeInner::Int64 => IDLValue::Int64(str.parse::<i64>()?),
+                _ => {
+                    return Err(Error::msg(format!(
+                        "type mismatch: {self} can not be of type {t}"
+                    )))
                 }
-            }
+            },
             _ => {
                 return Err(Error::msg(format!(
                     "type mismatch: {self} cannot be of type {t}"
@@ -292,6 +296,7 @@ impl IDLValue {
                 let t = v.deref().value_ty();
                 TypeInner::Opt(t)
             }
+            IDLValue::Blob(_) => TypeInner::Vec(TypeInner::Nat8.into()),
             IDLValue::Vec(ref vec) => {
                 let t = if vec.is_empty() {
                     TypeInner::Empty.into()
@@ -376,6 +381,7 @@ impl crate::CandidType for IDLValue {
                 }
                 Ok(())
             }
+            IDLValue::Blob(ref blob) => serializer.serialize_blob(blob),
             IDLValue::Record(ref vec) => {
                 let mut ser = serializer.serialize_struct()?;
                 for f in vec.iter() {
@@ -428,7 +434,7 @@ impl<'de> Visitor<'de> for IDLValueVisitor {
     visit_prim!(Int64, i64);
     visit_prim!(Float32, f32);
     visit_prim!(Float64, f64);
-    // Deserialize Candid specific types: Bignumber, principal, reversed, service, function
+    // Deserialize Candid specific types: Bignumber, principal, reversed, service, function, blob
     fn visit_byte_buf<E: de::Error>(self, value: Vec<u8>) -> DResult<E> {
         let (tag, mut bytes) = value.split_at(1);
         match tag[0] {
@@ -444,6 +450,7 @@ impl<'de> Visitor<'de> for IDLValueVisitor {
                 let v = crate::Principal::try_from(bytes).map_err(E::custom)?;
                 Ok(IDLValue::Principal(v))
             }
+            3u8 => Ok(IDLValue::Reserved),
             4u8 => {
                 let v = crate::Principal::try_from(bytes).map_err(E::custom)?;
                 Ok(IDLValue::Service(v))
@@ -457,7 +464,7 @@ impl<'de> Visitor<'de> for IDLValueVisitor {
                 let id = crate::Principal::try_from(bytes).map_err(E::custom)?;
                 Ok(IDLValue::Func(id, meth))
             }
-            3u8 => Ok(IDLValue::Reserved),
+            6u8 => Ok(IDLValue::Blob(bytes.to_vec())),
             _ => Err(de::Error::custom("unknown tag in visit_byte_buf")),
         }
     }
diff --git a/rust/candid/src/utils.rs b/rust/candid/src/utils.rs
index 64bee0a2..4889783f 100644
--- a/rust/candid/src/utils.rs
+++ b/rust/candid/src/utils.rs
@@ -3,13 +3,6 @@ use crate::ser::IDLBuilder;
 use crate::{CandidType, Error, Result};
 use serde::de::Deserialize;
 
-#[cfg(feature = "parser")]
-use crate::{check_prog, pretty_check_file};
-#[cfg(feature = "parser")]
-use crate::{pretty_parse, types::Type, TypeEnv};
-#[cfg(feature = "parser")]
-use std::path::Path;
-
 pub fn check_unique<'a, I, T>(sorted: I) -> Result<()>
 where
     T: 'a + PartialEq + std::fmt::Display,
@@ -29,93 +22,17 @@ where
     Ok(())
 }
 
-#[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-#[cfg(feature = "parser")]
-pub enum CandidSource<'a> {
-    File(&'a Path),
-    Text(&'a str),
-}
-#[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-#[cfg(feature = "parser")]
-impl<'a> CandidSource<'a> {
-    pub fn load(&self) -> Result<(TypeEnv, Option<Type>)> {
-        Ok(match self {
-            CandidSource::File(path) => pretty_check_file(path)?,
-            CandidSource::Text(str) => {
-                let ast = pretty_parse("", str)?;
-                let mut env = TypeEnv::new();
-                let actor = check_prog(&mut env, &ast)?;
-                (env, actor)
-            }
-        })
+pub fn pp_num_str(s: &str) -> String {
+    let mut groups = Vec::new();
+    for chunk in s.as_bytes().rchunks(3) {
+        let str = String::from_utf8_lossy(chunk);
+        groups.push(str);
     }
-}
-
-#[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-#[cfg(feature = "parser")]
-/// Check compatibility of two service types
-pub fn service_compatible(new: CandidSource, old: CandidSource) -> Result<()> {
-    let (mut env, t1) = new.load()?;
-    let t1 = t1.ok_or_else(|| Error::msg("new interface has no main service type"))?;
-    let (env2, t2) = old.load()?;
-    let t2 = t2.ok_or_else(|| Error::msg("old interface has no main service type"))?;
-    let mut gamma = std::collections::HashSet::new();
-    let t2 = env.merge_type(env2, t2);
-    crate::types::subtype::subtype(&mut gamma, &env, &t1, &t2)?;
-    Ok(())
-}
-
-#[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-#[cfg(feature = "parser")]
-/// Check structural equality of two service types
-pub fn service_equal(left: CandidSource, right: CandidSource) -> Result<()> {
-    let (mut env, t1) = left.load()?;
-    let t1 = t1.ok_or_else(|| Error::msg("left interface has no main service type"))?;
-    let (env2, t2) = right.load()?;
-    let t2 = t2.ok_or_else(|| Error::msg("right interface has no main service type"))?;
-    let mut gamma = std::collections::HashSet::new();
-    let t2 = env.merge_type(env2, t2);
-    crate::types::subtype::equal(&mut gamma, &env, &t1, &t2)?;
-    Ok(())
-}
-
-#[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-#[cfg(feature = "parser")]
-/// Take a did file and outputs the init args and the service type (without init args).
-/// If the original did file contains imports, the output flattens the type definitions.
-/// For now, the comments from the original did file is omitted.
-pub fn instantiate_candid(candid: CandidSource) -> Result<(Vec<Type>, (TypeEnv, Type))> {
-    use crate::types::TypeInner;
-    let (env, serv) = candid.load()?;
-    let serv = serv.ok_or_else(|| Error::msg("the Candid interface has no main service type"))?;
-    let serv = env.trace_type(&serv)?;
-    Ok(match serv.as_ref() {
-        TypeInner::Class(args, ty) => (args.clone(), (env, ty.clone())),
-        TypeInner::Service(_) => (vec![], (env, serv)),
-        _ => unreachable!(),
-    })
-}
-
-/// Merge canister metadata candid:args and candid:service into a service constructor.
-/// If candid:service already contains init args, returns the original did file.
-#[cfg_attr(docsrs, doc(cfg(feature = "parser")))]
-#[cfg(feature = "parser")]
-pub fn merge_init_args(candid: &str, init: &str) -> Result<(TypeEnv, Type)> {
-    use crate::parser::{types::IDLInitArgs, typing::check_init_args};
-    use crate::types::TypeInner;
-    let candid = CandidSource::Text(candid);
-    let (env, serv) = candid.load()?;
-    let serv = serv.ok_or_else(|| Error::msg("the Candid interface has no main service type"))?;
-    let serv = env.trace_type(&serv)?;
-    match serv.as_ref() {
-        TypeInner::Class(_, _) => Ok((env, serv)),
-        TypeInner::Service(_) => {
-            let prog = init.parse::<IDLInitArgs>()?;
-            let mut env2 = TypeEnv::new();
-            let args = check_init_args(&mut env2, &env, &prog)?;
-            Ok((env2, TypeInner::Class(args, serv).into()))
-        }
-        _ => unreachable!(),
+    groups.reverse();
+    if "-" == groups.first().unwrap() {
+        "-".to_string() + &groups[1..].join("_")
+    } else {
+        groups.join("_")
     }
 }
 
diff --git a/rust/candid/tests/number.rs b/rust/candid/tests/number.rs
index ecaf1b03..969ae398 100644
--- a/rust/candid/tests/number.rs
+++ b/rust/candid/tests/number.rs
@@ -1,3 +1,4 @@
+use candid::types::leb128::*;
 use candid::{Int, Nat};
 use num_traits::cast::ToPrimitive;
 
@@ -28,10 +29,10 @@ fn test_numbers() {
 
 #[test]
 fn pretty_print_numbers() {
-    assert_eq!(format!("{}", Nat::from(42)), "42");
-    assert_eq!(format!("{}", Nat::from(100)), "100");
-    assert_eq!(format!("{}", Nat::from(100000)), "100_000");
-    assert_eq!(format!("{}", Nat::from(1_234_567_890)), "1_234_567_890");
+    assert_eq!(format!("{}", Nat::from(42u8)), "42");
+    assert_eq!(format!("{}", Nat::from(100u8)), "100");
+    assert_eq!(format!("{}", Nat::from(100000u32)), "100_000");
+    assert_eq!(format!("{}", Nat::from(1_234_567_890u32)), "1_234_567_890");
     assert_eq!(format!("{}", Int::from(0)), "0");
     assert_eq!(format!("{}", Int::from(-1)), "-1");
     assert_eq!(format!("{}", Int::from(-123)), "-123");
@@ -51,10 +52,16 @@ fn random_i64() {
             let mut encoded = Vec::new();
             Int::from(x).encode(&mut encoded).unwrap();
             assert_eq!(expected, encoded);
+            encoded.clear();
+            encode_int(&mut encoded, x.into()).unwrap();
+            assert_eq!(expected, encoded);
         }
         let mut readable = &expected[..];
         let decoded = Int::decode(&mut readable).unwrap();
         assert_eq!(decoded.0.to_i64().unwrap(), x);
+        readable = &expected[..];
+        let decoded = decode_int(&mut readable).unwrap();
+        assert_eq!(decoded as i64, x);
     }
 }
 
@@ -70,20 +77,50 @@ fn random_u64() {
             let mut encoded = Vec::new();
             Nat::from(x).encode(&mut encoded).unwrap();
             assert_eq!(expected, encoded);
+            encoded.clear();
+            encode_nat(&mut encoded, x.into()).unwrap();
+            assert_eq!(expected, encoded);
         }
         let mut readable = &expected[..];
         let decoded = Nat::decode(&mut readable).unwrap();
         assert_eq!(decoded.0.to_u64().unwrap(), x);
+        readable = &expected[..];
+        let decoded = decode_nat(&mut readable).unwrap();
+        assert_eq!(decoded as u64, x);
     }
 }
 
 #[allow(clippy::cmp_owned)]
 #[test]
 fn operators() {
-    macro_rules! test_type {
-        ($res: ty, $( $t: ty )*) => ($(
+    macro_rules! test_type_nat {
+        ($( $t: ty )*) => ($(
+            let x: $t = 1;
+            let value = <Nat>::from(x + 1);
+
+            assert_eq!(value.clone() + x, 3u32);
+            assert_eq!(value.clone() - x, 1u32);
+            assert_eq!(value.clone() * x, 2u32);
+            assert_eq!(value.clone() / x, 2u32);
+            assert_eq!(value.clone() % x, 0u32);
+
+            assert_eq!(x + value.clone(), 3u32);
+            let result = std::panic::catch_unwind(|| x - value.clone());
+            assert!(result.is_err());
+            assert_eq!(x * value.clone(), 2u32);
+            assert_eq!(x / value.clone(), 0u32);
+            assert_eq!(x % value.clone(), 1u32);
+
+            assert!(value.clone() < <Nat>::from(x + 2));
+            assert!(<Nat>::from(x + 2) > value.clone());
+            assert!(x < <Nat>::from(x + 2));
+            assert!(<Nat>::from(x + 2) > x);
+        )*)
+    }
+    macro_rules! test_type_int {
+        ($( $t: ty )*) => ($(
             let x: $t = 1;
-            let value = <$res>::from(x + 1);
+            let value = <Int>::from(x + 1);
 
             assert_eq!(value.clone() + x, 3);
             assert_eq!(value.clone() - x, 1);
@@ -92,20 +129,20 @@ fn operators() {
             assert_eq!(value.clone() % x, 0);
 
             assert_eq!(x + value.clone(), 3);
-            assert_eq!(x - value.clone(), 1);
+            assert_eq!(x - value.clone(), -1);
             assert_eq!(x * value.clone(), 2);
-            assert_eq!(x / value.clone(), 2);
-            assert_eq!(x % value.clone(), 0);
+            assert_eq!(x / value.clone(), 0);
+            assert_eq!(x % value.clone(), 1);
 
-            assert!(value.clone() < <$res>::from(x + 2));
-            assert!(<$res>::from(x + 2) > value.clone());
-            assert!(x < <$res>::from(x + 2));
-            assert!(<$res>::from(x + 2) > x);
+            assert!(value.clone() < <Int>::from(x + 2));
+            assert!(<Int>::from(x + 2) > value.clone());
+            assert!(x < <Int>::from(x + 2));
+            assert!(<Int>::from(x + 2) > x);
         )*)
     }
 
-    test_type!( Nat, usize u8 u16 u32 u64 u128 );
-    test_type!( Int, usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 );
+    test_type_nat!( usize u8 u16 u32 u64 u128 );
+    test_type_int!( usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 );
 }
 
 fn check(num: &str, int_hex: &str, nat_hex: &str) {
diff --git a/rust/candid/tests/serde.rs b/rust/candid/tests/serde.rs
index 5fb612e8..88be8657 100644
--- a/rust/candid/tests/serde.rs
+++ b/rust/candid/tests/serde.rs
@@ -46,9 +46,9 @@ fn test_bool() {
 #[test]
 fn test_integer() {
     all_check(Int::from(42), "4449444c00017c2a");
-    all_check(Nat::from(42), "4449444c00017d2a");
+    all_check(Nat::from(42u16), "4449444c00017d2a");
     all_check(Int::from(1_234_567_890), "4449444c00017cd285d8cc04");
-    all_check(Nat::from(1_234_567_890), "4449444c00017dd285d8cc04");
+    all_check(Nat::from(1_234_567_890u64), "4449444c00017dd285d8cc04");
     all_check(Nat::from(5_000_000_000u64), "4449444c00017d80e497d012");
     all_check(Int::from(-1_234_567_890), "4449444c00017caefaa7b37b");
     all_check(Box::new(Int::from(42)), "4449444c00017c2a");
@@ -417,6 +417,7 @@ fn test_newtype() {
 }
 
 #[test]
+#[cfg(feature = "serde_bytes")]
 fn test_serde_bytes() {
     use serde_bytes::ByteBuf;
     all_check(
@@ -439,6 +440,7 @@ fn test_serde_bytes() {
 }
 
 #[test]
+#[cfg(feature = "serde_bytes")]
 fn test_rc_bytes() {
     use serde_bytes::ByteBuf;
     use std::rc::Rc;
@@ -614,7 +616,7 @@ fn test_variant() {
     test_decode(&bytes, &Some(Unit::Foo));
     let bytes = encode(&E::Baz {
         a: 42.into(),
-        b: 42.into(),
+        b: 42u8.into(),
     });
     test_decode(&bytes, &None::<Unit>);
     let bytes = encode(&E::Bar(true, 42.into()));
diff --git a/rust/candid/tests/types.rs b/rust/candid/tests/types.rs
index db24acbf..7780e040 100644
--- a/rust/candid/tests/types.rs
+++ b/rust/candid/tests/types.rs
@@ -3,11 +3,11 @@
 use std::fmt::Debug;
 
 use candid::{
-    candid_method, field,
+    candid_method, record,
     ser::IDLBuilder,
     types::value::{IDLValue, IDLValueVisitor},
     types::{get_type, Serializer, Type, TypeInner},
-    CandidType, Decode, Deserialize, Encode, Int,
+    variant, CandidType, Decode, Deserialize, Encode, Int,
 };
 use serde::de::DeserializeOwned;
 
@@ -110,11 +110,7 @@ fn test_struct() {
     }
     assert_eq!(
         A::ty(),
-        TypeInner::Record(vec![
-            field! {bar: TypeInner::Bool.into()},
-            field! {foo: TypeInner::Int.into()}
-        ])
-        .into()
+        record! { foo: TypeInner::Int.into(); bar: TypeInner::Bool.into() }
     );
 
     #[derive(Debug, CandidType)]
@@ -125,11 +121,7 @@ fn test_struct() {
     let res = G { g1: 42, g2: true };
     assert_eq!(
         get_type(&res),
-        TypeInner::Record(vec![
-            field! {g1: TypeInner::Int32.into()},
-            field! {g2: TypeInner::Bool.into()}
-        ])
-        .into()
+        record! { g1: TypeInner::Int32.into(); g2: TypeInner::Bool.into() }
     );
 
     #[derive(Debug, CandidType)]
@@ -139,11 +131,7 @@ fn test_struct() {
     }
     assert_eq!(
         List::ty(),
-        TypeInner::Record(vec![
-            field!{head: TypeInner::Int32.into()},
-            field!{tail: TypeInner::Opt(TypeInner::Knot(candid::types::TypeId::of::<List>()).into()).into()}
-        ])
-        .into()
+        record! { head: TypeInner::Int32.into(); tail: TypeInner::Opt(TypeInner::Knot(candid::types::TypeId::of::<List>()).into()).into() }
     );
 }
 
@@ -161,26 +149,12 @@ fn test_variant() {
     let v = E::Bar(true, 42);
     assert_eq!(
         get_type(&v),
-        TypeInner::Variant(vec![
-            field! {Bar:
-                TypeInner::Record(vec![
-                    field!{0: TypeInner::Bool.into()},
-                    field!{1: TypeInner::Int32.into()}
-                ])
-                .into()
-            },
-            field! {
-                Baz:
-                TypeInner::Record(vec![
-                    field!{a: TypeInner::Int32.into()},
-                    field!{b: TypeInner::Nat32.into()}
-                ])
-                .into()
-            },
-            field! {Foo: TypeInner::Null.into()},
-            field! {Newtype: TypeInner::Bool.into()},
-        ])
-        .into()
+        variant! {
+            Baz: record!{ a: TypeInner::Int32.into(); b: TypeInner::Nat32.into() };
+            Foo: TypeInner::Null.into();
+            Bar: record!{ 0: TypeInner::Bool.into(); 1: TypeInner::Int32.into() };
+            Newtype: TypeInner::Bool.into();
+        }
     );
 }
 
diff --git a/rust/candid_derive/Cargo.toml b/rust/candid_derive/Cargo.toml
index 60866ad5..691c4bcb 100644
--- a/rust/candid_derive/Cargo.toml
+++ b/rust/candid_derive/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "candid_derive"
-version = "0.6.4"
+version = "0.6.5"
 edition = "2021"
 authors = ["DFINITY Team"]
 description = "Macros implementation of #[derive(CandidType)] for the Candid."
diff --git a/rust/candid_derive/src/func.rs b/rust/candid_derive/src/func.rs
index a8da2fac..2af580c9 100644
--- a/rust/candid_derive/src/func.rs
+++ b/rust/candid_derive/src/func.rs
@@ -18,8 +18,8 @@ struct Method {
 // Hopefully, we can have an attribute on impl, then we don't need global state.
 lazy_static! {
     static ref METHODS: Mutex<Option<BTreeMap<String, Method>>> =
-        Mutex::new(Some(Default::default()));
-    static ref INIT: Mutex<Option<Option<Vec<String>>>> = Mutex::new(Some(Default::default()));
+        Mutex::new(Some(BTreeMap::default()));
+    static ref INIT: Mutex<Option<Option<Vec<String>>>> = Mutex::new(Some(Option::default()));
 }
 
 pub(crate) fn candid_method(attrs: Vec<Meta>, fun: ItemFn) -> Result<TokenStream> {
@@ -135,7 +135,7 @@ pub(crate) fn export_service(path: Option<TokenStream>) -> TokenStream {
             fn __export_service() -> String {
                 #service
                 #actor
-                let result = #candid::bindings::candid::compile(&env.env, &actor);
+                let result = #candid::pretty::candid::compile(&env.env, &actor);
                 format!("{}", result)
             }
         };
@@ -199,7 +199,7 @@ fn get_candid_attribute(attrs: Vec<Meta>) -> Result<CandidAttribute> {
                 let mode = p.get_ident().unwrap().to_string();
                 match mode.as_ref() {
                     "query" | "composite_query" | "update" | "oneway" => {
-                        res.method_type = Some(mode)
+                        res.method_type = Some(mode);
                     }
                     "init" => res.is_init = true,
                     _ => return Err(Error::new_spanned(p, "unknown mode")),
diff --git a/rust/candid_derive/src/lib.rs b/rust/candid_derive/src/lib.rs
index 9c9ee8a7..eb26e426 100644
--- a/rust/candid_derive/src/lib.rs
+++ b/rust/candid_derive/src/lib.rs
@@ -38,7 +38,7 @@ pub fn export_service(input: TokenStream) -> TokenStream {
 #[inline]
 pub(crate) fn idl_hash(id: &str) -> u32 {
     let mut s: u32 = 0;
-    for c in id.as_bytes().iter() {
+    for c in id.as_bytes() {
         s = s.wrapping_mul(223).wrapping_add(*c as u32);
     }
     s
diff --git a/rust/candid_parser/Cargo.toml b/rust/candid_parser/Cargo.toml
new file mode 100644
index 00000000..f386fd03
--- /dev/null
+++ b/rust/candid_parser/Cargo.toml
@@ -0,0 +1,57 @@
+[package]
+name = "candid_parser"
+version = "0.1.0"
+edition = "2021"
+authors = ["DFINITY Team"]
+description = "Candid is an interface description language (IDL) for interacting with canisters running on the Internet Computer."
+homepage = "https://internetcomputer.org/docs/current/developer-docs/build/candid/candid-concepts"
+documentation = "https://docs.rs/candid_parser"
+repository = "https://github.com/dfinity/candid"
+license = "Apache-2.0"
+readme = "README.md"
+categories = ["encoding", "parsing", "wasm"]
+keywords = ["internet-computer", "idl", "candid", "dfinity", "parser"]
+include = ["src", "Cargo.toml", "build.rs", "LICENSE", "README.md"]
+build = "build.rs"
+
+[build-dependencies]
+lalrpop = "0.20.0"
+
+[dependencies]
+candid = { path = "../candid", version = "0.10", features = ["all"] }
+codespan-reporting = "0.11"
+hex.workspace = true
+num-bigint.workspace = true
+pretty.workspace = true
+thiserror.workspace = true
+anyhow.workspace = true
+
+lalrpop-util = "0.20.0"
+logos = "0.13"
+convert_case = "0.6"
+
+arbitrary = { workspace = true, optional = true }
+# Don't upgrade serde_dhall. It will introduce dependency with invalid license.
+serde_dhall = { version = "0.11", default-features = false, optional = true }
+fake = { version = "2.4", optional = true }
+rand = { version = "0.8", optional = true }
+num-traits = { workspace = true, optional = true }
+serde = { workspace = true, optional = true }
+
+
+[dev-dependencies]
+goldenfile = "1.1.0"
+test-generator = "0.3.0"
+rand.workspace = true
+
+[features]
+configs = ["serde_dhall"]
+random = ["configs", "arbitrary", "fake", "rand", "num-traits", "serde"]
+all = ["random"]
+
+# docs.rs-specific configuration
+# To test locally: RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc --features all
+[package.metadata.docs.rs]
+features = ["all"]
+# defines the configuration attribute `docsrs`
+rustdoc-args = ["--cfg", "docsrs"]
diff --git a/rust/candid_parser/LICENSE b/rust/candid_parser/LICENSE
new file mode 120000
index 00000000..30cff740
--- /dev/null
+++ b/rust/candid_parser/LICENSE
@@ -0,0 +1 @@
+../../LICENSE
\ No newline at end of file
diff --git a/rust/candid/build.rs b/rust/candid_parser/build.rs
similarity index 62%
rename from rust/candid/build.rs
rename to rust/candid_parser/build.rs
index e6396a04..d8dc3bac 100644
--- a/rust/candid/build.rs
+++ b/rust/candid_parser/build.rs
@@ -1,8 +1,7 @@
 fn main() {
-    #[cfg(feature = "parser")]
     lalrpop::Configuration::new()
         .use_cargo_dir_conventions()
         .emit_rerun_directives(true)
-        .process_file("src/parser/grammar.lalrpop")
+        .process_file("src/grammar.lalrpop")
         .unwrap();
 }
diff --git a/rust/candid/src/bindings/analysis.rs b/rust/candid_parser/src/bindings/analysis.rs
similarity index 98%
rename from rust/candid/src/bindings/analysis.rs
rename to rust/candid_parser/src/bindings/analysis.rs
index a6cc6d22..6d8f717c 100644
--- a/rust/candid/src/bindings/analysis.rs
+++ b/rust/candid_parser/src/bindings/analysis.rs
@@ -1,5 +1,5 @@
-use crate::types::{Type, TypeEnv, TypeInner};
 use crate::Result;
+use candid::types::{Type, TypeEnv, TypeInner};
 use std::collections::BTreeSet;
 
 /// Same as chase_actor, with seen set as part of the type. Used for chasing type names from type definitions.
diff --git a/rust/candid/src/bindings/javascript.rs b/rust/candid_parser/src/bindings/javascript.rs
similarity index 93%
rename from rust/candid/src/bindings/javascript.rs
rename to rust/candid_parser/src/bindings/javascript.rs
index 739fba25..02476638 100644
--- a/rust/candid/src/bindings/javascript.rs
+++ b/rust/candid_parser/src/bindings/javascript.rs
@@ -1,6 +1,7 @@
 use super::analysis::{chase_actor, chase_types, infer_rec};
-use crate::pretty::*;
-use crate::types::{Field, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
+use candid::pretty::candid::pp_mode;
+use candid::pretty::utils::*;
+use candid::types::{Field, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
 use pretty::RcDoc;
 use std::collections::BTreeSet;
 
@@ -170,11 +171,11 @@ fn pp_args(args: &[Type]) -> RcDoc {
     enclose("[", doc, "]")
 }
 
-fn pp_modes(modes: &[crate::types::FuncMode]) -> RcDoc {
+fn pp_modes(modes: &[candid::types::FuncMode]) -> RcDoc {
     let doc = concat(
         modes
             .iter()
-            .map(|m| str("'").append(m.to_doc()).append("'")),
+            .map(|m| str("'").append(pp_mode(m)).append("'")),
         ",",
     );
     enclose("[", doc, "]")
@@ -267,10 +268,10 @@ pub fn compile(env: &TypeEnv, actor: &Option<Type>) -> String {
 }
 
 pub mod value {
-    use super::super::candid::value::number_to_string;
-    use crate::pretty::*;
-    use crate::types::value::{IDLArgs, IDLField, IDLValue};
-    use crate::types::Label;
+    use candid::pretty::candid::value::number_to_string;
+    use candid::pretty::utils::*;
+    use candid::types::value::{IDLArgs, IDLField, IDLValue};
+    use candid::types::Label;
     use pretty::RcDoc;
 
     fn is_tuple(v: &IDLValue) -> bool {
@@ -333,6 +334,10 @@ pub mod value {
             Text(s) => RcDoc::text(format!("'{}'", s.escape_debug())),
             None => RcDoc::text("[]"),
             Opt(v) => enclose_space("[", pp_value(v), "]"),
+            Blob(blob) => {
+                let body = concat(blob.iter().map(RcDoc::as_string), ",");
+                enclose_space("[", body, "]")
+            }
             Vec(vs) => {
                 let body = concat(vs.iter().map(pp_value), ",");
                 enclose_space("[", body, "]")
@@ -357,9 +362,9 @@ pub mod value {
 
 pub mod test {
     use super::value;
-    use crate::parser::test::{HostAssert, HostTest, Test};
-    use crate::pretty::*;
-    use crate::TypeEnv;
+    use crate::test::{HostAssert, HostTest, Test};
+    use candid::pretty::utils::*;
+    use candid::TypeEnv;
     use pretty::RcDoc;
 
     fn pp_hex(bytes: &[u8]) -> RcDoc {
@@ -367,7 +372,7 @@ pub mod test {
             .append(RcDoc::as_string(hex::encode(bytes)))
             .append("', 'hex')")
     }
-    fn pp_encode<'a>(args: &'a crate::IDLArgs, tys: &'a [crate::types::Type]) -> RcDoc<'a> {
+    fn pp_encode<'a>(args: &'a candid::IDLArgs, tys: &'a [candid::types::Type]) -> RcDoc<'a> {
         let vals = value::pp_args(args);
         let tys = super::pp_args(tys);
         let items = [tys, vals];
@@ -375,7 +380,7 @@ pub mod test {
         str("IDL.encode").append(enclose("(", params, ")"))
     }
 
-    fn pp_decode<'a>(bytes: &'a [u8], tys: &'a [crate::types::Type]) -> RcDoc<'a> {
+    fn pp_decode<'a>(bytes: &'a [u8], tys: &'a [candid::types::Type]) -> RcDoc<'a> {
         let hex = pp_hex(bytes);
         let tys = super::pp_args(tys);
         let items = [tys, hex];
@@ -404,7 +409,7 @@ import { Principal } from './principal';
         for (i, assert) in test.asserts.iter().enumerate() {
             let mut types = Vec::new();
             for ty in assert.typ.iter() {
-                types.push(env.ast_to_type(ty).unwrap());
+                types.push(crate::typing::ast_to_type(&env, ty).unwrap());
             }
             let host = HostTest::from_assert(assert, &env, &types);
             let mut expects = Vec::new();
diff --git a/rust/candid_parser/src/bindings/mod.rs b/rust/candid_parser/src/bindings/mod.rs
new file mode 100644
index 00000000..ae2a95b4
--- /dev/null
+++ b/rust/candid_parser/src/bindings/mod.rs
@@ -0,0 +1,8 @@
+//! Candid bindings for different languages.
+// This module assumes the input are type checked, it is safe to use unwrap.
+
+pub mod analysis;
+pub mod javascript;
+pub mod motoko;
+pub mod rust;
+pub mod typescript;
diff --git a/rust/candid/src/bindings/motoko.rs b/rust/candid_parser/src/bindings/motoko.rs
similarity index 92%
rename from rust/candid/src/bindings/motoko.rs
rename to rust/candid_parser/src/bindings/motoko.rs
index 48148e68..d0fcdbd4 100644
--- a/rust/candid/src/bindings/motoko.rs
+++ b/rust/candid_parser/src/bindings/motoko.rs
@@ -1,10 +1,10 @@
 // This module implements the Candid to Motoko binding as specified in
 // https://github.com/dfinity/motoko/blob/master/design/IDL-Motoko.md
 
-use super::candid::is_valid_as_id;
-use crate::pretty::*;
-use crate::types::FuncMode;
-use crate::types::{Field, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
+use candid::pretty::candid::is_valid_as_id;
+use candid::pretty::utils::*;
+use candid::types::FuncMode;
+use candid::types::{Field, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
 use pretty::RcDoc;
 
 // The definition of tuple is language specific.
@@ -84,7 +84,9 @@ fn escape(id: &str, is_method: bool) -> RcDoc {
             str(id)
         }
     } else if !is_method {
-        str("_").append(crate::idl_hash(id).to_string()).append("_")
+        str("_")
+            .append(candid::idl_hash(id).to_string())
+            .append("_")
     } else {
         panic!("Candid method {id} is not a valid Motoko id");
     }
@@ -125,8 +127,12 @@ fn pp_ty(ty: &Type) -> RcDoc {
             }
         }
         Variant(ref fs) => {
-            let fields = concat(fs.iter().map(pp_variant), ";");
-            enclose_space("{", fields, "}")
+            if fs.is_empty() {
+                str("{#}")
+            } else {
+                let fields = concat(fs.iter().map(pp_variant), ";");
+                enclose_space("{", fields, "}")
+            }
         }
         Func(ref func) => pp_function(func),
         Service(ref serv) => pp_service(serv),
diff --git a/rust/candid/src/bindings/rust.rs b/rust/candid_parser/src/bindings/rust.rs
similarity index 95%
rename from rust/candid/src/bindings/rust.rs
rename to rust/candid_parser/src/bindings/rust.rs
index fe399dbb..ee1b1b8c 100644
--- a/rust/candid/src/bindings/rust.rs
+++ b/rust/candid_parser/src/bindings/rust.rs
@@ -1,6 +1,6 @@
 use super::analysis::{chase_actor, infer_rec};
-use crate::pretty::*;
-use crate::types::{Field, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
+use candid::pretty::utils::*;
+use candid::types::{Field, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
 use convert_case::{Case, Casing};
 use pretty::RcDoc;
 use std::collections::BTreeSet;
@@ -14,14 +14,11 @@ pub enum Target {
 
 #[derive(Clone)]
 pub struct Config {
-    pub candid_crate: String,
-    /// Applies to all types for now
-    pub type_attributes: String,
-    /// Only generates SERVICE struct if canister_id is not provided
-    pub canister_id: Option<crate::Principal>,
-    /// Service name when canister id is provided
-    pub service_name: String,
-    pub target: Target,
+    candid_crate: String,
+    type_attributes: String,
+    canister_id: Option<candid::Principal>,
+    service_name: String,
+    target: Target,
 }
 impl Config {
     pub fn new() -> Self {
@@ -33,6 +30,29 @@ impl Config {
             target: Target::CanisterCall,
         }
     }
+    pub fn set_candid_crate(&mut self, name: String) -> &mut Self {
+        self.candid_crate = name;
+        self
+    }
+    /// Applies to all types for now
+    pub fn set_type_attributes(&mut self, attr: String) -> &mut Self {
+        self.type_attributes = attr;
+        self
+    }
+    /// Only generates SERVICE struct if canister_id is not provided
+    pub fn set_canister_id(&mut self, id: candid::Principal) -> &mut Self {
+        self.canister_id = Some(id);
+        self
+    }
+    /// Service name when canister id is provided
+    pub fn set_service_name(&mut self, name: String) -> &mut Self {
+        self.service_name = name;
+        self
+    }
+    pub fn set_target(&mut self, name: Target) -> &mut Self {
+        self.target = name;
+        self
+    }
 }
 impl Default for Config {
     fn default() -> Self {
@@ -62,7 +82,7 @@ fn ident_(id: &str, case: Option<Case>) -> (RcDoc, bool) {
         || id.starts_with(|c: char| !c.is_ascii_alphabetic() && c != '_')
         || id.chars().any(|c| !c.is_ascii_alphanumeric() && c != '_')
     {
-        return (RcDoc::text(format!("_{}_", crate::idl_hash(id))), true);
+        return (RcDoc::text(format!("_{}_", candid::idl_hash(id))), true);
     }
     let (is_rename, id) = if let Some(case) = case {
         let new_id = id.to_case(case);
@@ -269,7 +289,7 @@ fn pp_args(args: &[Type]) -> RcDoc {
 fn pp_ty_func(f: &Function) -> RcDoc {
     let args = pp_args(&f.args);
     let rets = pp_args(&f.rets);
-    let modes = super::candid::pp_modes(&f.modes);
+    let modes = candid::pretty::candid::pp_modes(&f.modes);
     args.append(" ->")
         .append(RcDoc::space())
         .append(rets.append(modes))
diff --git a/rust/candid/src/bindings/typescript.rs b/rust/candid_parser/src/bindings/typescript.rs
similarity index 93%
rename from rust/candid/src/bindings/typescript.rs
rename to rust/candid_parser/src/bindings/typescript.rs
index b7247382..50a738ec 100644
--- a/rust/candid/src/bindings/typescript.rs
+++ b/rust/candid_parser/src/bindings/typescript.rs
@@ -1,6 +1,6 @@
 use super::javascript::{ident, is_tuple};
-use crate::pretty::*;
-use crate::types::{Field, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
+use candid::pretty::utils::*;
+use candid::types::{Field, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
 use pretty::RcDoc;
 
 fn pp_ty<'a>(env: &'a TypeEnv, ty: &'a Type, is_ref: bool) -> RcDoc<'a> {
@@ -73,12 +73,18 @@ fn pp_ty<'a>(env: &'a TypeEnv, ty: &'a Type, is_ref: bool) -> RcDoc<'a> {
                 enclose_space("{", fields, "}")
             }
         }
-        Variant(ref fs) => strict_concat(
-            fs.iter()
-                .map(|f| enclose_space("{", pp_field(env, f, is_ref), "}")),
-            " |",
-        )
-        .nest(INDENT_SPACE),
+        Variant(ref fs) => {
+            if fs.is_empty() {
+                str("never")
+            } else {
+                strict_concat(
+                    fs.iter()
+                        .map(|f| enclose_space("{", pp_field(env, f, is_ref), "}")),
+                    " |",
+                )
+                .nest(INDENT_SPACE)
+            }
+        }
         Func(_) => str("[Principal, string]"),
         Service(_) => str("Principal"),
         Class(_, _) => unreachable!(),
diff --git a/rust/candid/src/parser/configs.rs b/rust/candid_parser/src/configs.rs
similarity index 99%
rename from rust/candid/src/parser/configs.rs
rename to rust/candid_parser/src/configs.rs
index 39371c86..7acceb41 100644
--- a/rust/candid/src/parser/configs.rs
+++ b/rust/candid_parser/src/configs.rs
@@ -1,5 +1,5 @@
-use crate::types::Type;
 use crate::Result;
+use candid::types::Type;
 use serde::de::DeserializeOwned;
 use serde_dhall::{from_simple_value, SimpleValue};
 
diff --git a/rust/candid_parser/src/error.rs b/rust/candid_parser/src/error.rs
new file mode 100644
index 00000000..db8e86d3
--- /dev/null
+++ b/rust/candid_parser/src/error.rs
@@ -0,0 +1,126 @@
+//! When serializing or deserializing Candid goes wrong.
+
+use codespan_reporting::diagnostic::Label;
+use std::io;
+use thiserror::Error;
+
+use crate::token;
+use codespan_reporting::{
+    diagnostic::Diagnostic,
+    files::{Error as ReportError, SimpleFile},
+    term::{self, termcolor::StandardStream},
+};
+
+pub type Result<T = ()> = std::result::Result<T, Error>;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("Candid parser error: {0}")]
+    Parse(#[from] token::ParserError),
+
+    #[error(transparent)]
+    Custom(#[from] anyhow::Error),
+
+    #[error(transparent)]
+    CandidError(#[from] ::candid::Error),
+}
+
+impl Error {
+    pub fn msg<T: ToString>(msg: T) -> Self {
+        Error::Custom(anyhow::anyhow!(msg.to_string()))
+    }
+
+    pub fn report(&self) -> Diagnostic<()> {
+        match self {
+            Error::Parse(e) => {
+                use lalrpop_util::ParseError::*;
+                let mut diag = Diagnostic::error().with_message("parser error");
+                let label = match e {
+                    User { error } => {
+                        Label::primary((), error.span.clone()).with_message(&error.err)
+                    }
+                    InvalidToken { location } => {
+                        Label::primary((), *location..location + 1).with_message("Invalid token")
+                    }
+                    UnrecognizedEof { location, expected } => {
+                        diag = diag.with_notes(report_expected(expected));
+                        Label::primary((), *location..location + 1).with_message("Unexpected EOF")
+                    }
+                    UnrecognizedToken { token, expected } => {
+                        diag = diag.with_notes(report_expected(expected));
+                        Label::primary((), token.0..token.2).with_message("Unexpected token")
+                    }
+                    ExtraToken { token } => {
+                        Label::primary((), token.0..token.2).with_message("Extra token")
+                    }
+                };
+                diag.with_labels(vec![label])
+            }
+            Error::Custom(e) => Diagnostic::error().with_message(e.to_string()),
+            Error::CandidError(e) => Diagnostic::error().with_message(e.to_string()),
+        }
+    }
+}
+
+fn report_expected(expected: &[String]) -> Vec<String> {
+    if expected.is_empty() {
+        return Vec::new();
+    }
+    use pretty::RcDoc;
+    let doc: RcDoc<()> = RcDoc::intersperse(
+        expected.iter().map(RcDoc::text),
+        RcDoc::text(",").append(RcDoc::softline()),
+    );
+    let header = if expected.len() == 1 {
+        "Expects"
+    } else {
+        "Expects one of"
+    };
+    let doc = RcDoc::text(header).append(RcDoc::softline().append(doc));
+    vec![doc.pretty(70).to_string()]
+}
+
+impl From<io::Error> for Error {
+    fn from(e: io::Error) -> Error {
+        Error::msg(format!("io error: {e}"))
+    }
+}
+
+impl From<ReportError> for Error {
+    fn from(e: ReportError) -> Error {
+        Error::msg(e)
+    }
+}
+#[cfg_attr(docsrs, doc(cfg(feature = "random")))]
+#[cfg(feature = "random")]
+impl From<arbitrary::Error> for Error {
+    fn from(e: arbitrary::Error) -> Error {
+        Error::msg(format!("arbitrary error: {e}"))
+    }
+}
+
+#[cfg_attr(docsrs, doc(cfg(feature = "configs")))]
+#[cfg(feature = "configs")]
+impl From<serde_dhall::Error> for Error {
+    fn from(e: serde_dhall::Error) -> Error {
+        Error::msg(format!("dhall error: {e}"))
+    }
+}
+
+pub fn pretty_parse<T>(name: &str, str: &str) -> Result<T>
+where
+    T: std::str::FromStr<Err = Error>,
+{
+    str.parse::<T>().or_else(|e| {
+        pretty_diagnose(name, str, &e)?;
+        Err(e)
+    })
+}
+
+pub fn pretty_diagnose(file_name: &str, source: &str, e: &Error) -> Result<()> {
+    let writer = StandardStream::stderr(term::termcolor::ColorChoice::Auto);
+    let config = term::Config::default();
+    let file = SimpleFile::new(file_name, source);
+    term::emit(&mut writer.lock(), &config, &file, &e.report())?;
+    Ok(())
+}
diff --git a/rust/candid/src/parser/grammar.lalrpop b/rust/candid_parser/src/grammar.lalrpop
similarity index 96%
rename from rust/candid/src/parser/grammar.lalrpop
rename to rust/candid_parser/src/grammar.lalrpop
index 6f0e2356..0951556c 100644
--- a/rust/candid/src/parser/grammar.lalrpop
+++ b/rust/candid_parser/src/grammar.lalrpop
@@ -1,10 +1,10 @@
-use crate::types::value::{IDLField, IDLValue, IDLArgs, VariantValue};
-use crate::types::{TypeEnv, FuncMode};
-use crate::utils::check_unique;
 use super::types::{IDLType, PrimType, TypeField, FuncType, Binding, Dec, IDLProg, IDLTypes, IDLInitArgs};
 use super::test::{Assert, Input, Test};
 use super::token::{Token, error2, LexicalError, Span};
-use crate::{Principal, types::Label};
+use candid::{Principal, types::Label};
+use candid::types::value::{IDLField, IDLValue, IDLArgs, VariantValue};
+use candid::types::{TypeEnv, FuncMode};
+use candid::utils::check_unique;
 
 grammar;
 
@@ -57,10 +57,7 @@ pub Arg: IDLValue = {
     "bool" => IDLValue::Bool(<>),
     NumLiteral => <>,
     Text => IDLValue::Text(<>),
-    Bytes => {
-        let values: Vec<_> = <>.into_iter().map(|v| IDLValue::Nat8(v)).collect();
-        IDLValue::Vec(values)
-    },
+    Bytes => IDLValue::Blob(<>),
     "null" => IDLValue::Null,
     "opt" <Arg> => IDLValue::Opt(Box::new(<>)),
     "vec" "{" <SepBy<AnnVal, ";">> "}" => IDLValue::Vec(<>),
@@ -116,7 +113,7 @@ AnnVal: IDLValue = {
     <Arg> => <>,
     <arg:Sp<Arg>> ":" <typ:Sp<Typ>> =>? {
         let env = TypeEnv::new();
-        let typ = env.ast_to_type(&typ.0).map_err(|e| error2(e, typ.1))?;
+        let typ = crate::typing::ast_to_type(&env, &typ.0).map_err(|e| error2(e, typ.1))?;
         arg.0.annotate_type(true, &env, &typ).map_err(|e| error2(e, arg.1))
     }
 }
diff --git a/rust/candid_parser/src/grammar.rs b/rust/candid_parser/src/grammar.rs
new file mode 100644
index 00000000..8fa4f72f
--- /dev/null
+++ b/rust/candid_parser/src/grammar.rs
@@ -0,0 +1,2 @@
+#![allow(clippy::all)]
+include!(concat!(env!("OUT_DIR"), "/grammar.rs"));
diff --git a/rust/candid_parser/src/lib.rs b/rust/candid_parser/src/lib.rs
new file mode 100644
index 00000000..b2ea48c9
--- /dev/null
+++ b/rust/candid_parser/src/lib.rs
@@ -0,0 +1,152 @@
+//! # Candid Parser
+//!
+//! Everything from `candid` crate is re-exported here. Users don't have to add `candid` as their dependency in `Cargo.toml`.
+//!
+//! Provides parser for Candid type and value.
+//!  * `str.parse::<IDLProg>()` parses the Candid signature file to Candid AST.
+//!  * `parse_idl_args()` parses the Candid value in text format to a struct `IDLArg` that can be used for serialization and deserialization between Candid and an enum type `IDLValue` in Rust.
+
+//! ## Parse [`candid::IDLArgs`]
+//!
+//! We provide a parser to parse Candid values in text format.
+//!
+//! ```
+//! # fn f() -> anyhow::Result<()> {
+//! use candid::{IDLArgs, TypeEnv};
+//! use candid_parser::parse_idl_args;
+//! // Candid values represented in text format
+//! let text_value = r#"
+//!      (42, opt true, vec {1;2;3},
+//!       opt record {label="text"; 42="haha"})
+//! "#;
+//!
+//! // Parse text format into IDLArgs for serialization
+//! let args: IDLArgs = parse_idl_args(text_value)?;
+//! let encoded: Vec<u8> = args.to_bytes()?;
+//!
+//! // Deserialize into IDLArgs
+//! let decoded: IDLArgs = IDLArgs::from_bytes(&encoded)?;
+//! assert_eq!(encoded, decoded.to_bytes()?);
+//!
+//! // Convert IDLArgs to text format
+//! let output: String = decoded.to_string();
+//! let parsed_args: IDLArgs = parse_idl_args(&output)?;
+//! let annotated_args = args.annotate_types(true, &TypeEnv::new(), &parsed_args.get_types())?;
+//! assert_eq!(annotated_args, parsed_args);
+//! # Ok(())
+//! # }
+//! ```
+//! Note that when parsing Candid values, we assume the number literals are always of type `Int`.
+//! This can be changed by providing the type of the method arguments, which can usually be obtained
+//! by parsing a Candid file in the following section.
+//!
+//! ## Operating on Candid AST
+//!
+//! We provide a parser and type checker for Candid files specifying the service interface.
+//!
+//! ```
+//! # fn f() -> anyhow::Result<()> {
+//! use candid::{TypeEnv, types::{Type, TypeInner}};
+//! use candid_parser::{IDLProg, check_prog};
+//! let did_file = r#"
+//!     type List = opt record { head: int; tail: List };
+//!     type byte = nat8;
+//!     service : {
+//!       f : (byte, int, nat, int8) -> (List);
+//!       g : (List) -> (int) query;
+//!     }
+//! "#;
+//!
+//! // Parse did file into an AST
+//! let ast: IDLProg = did_file.parse()?;
+//!
+//! // Type checking a given .did file
+//! // let (env, opt_actor) = check_file("a.did")?;
+//! // Or alternatively, use check_prog to check in-memory did file
+//! // Note that file import is ignored by check_prog.
+//! let mut env = TypeEnv::new();
+//! let actor: Type = check_prog(&mut env, &ast)?.unwrap();
+//!
+//! let method = env.get_method(&actor, "g").unwrap();
+//! assert_eq!(method.is_query(), true);
+//! assert_eq!(method.args, vec![TypeInner::Var("List".to_string()).into()]);
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! ## Serializing untyped Candid values with type annotations.
+//!
+//! With type signatures from the Candid file, [`candid::IDLArgs`](parser/value/struct.IDLArgs.html)
+//! uses `to_bytes_with_types` function to serialize arguments directed by the Candid types.
+//! This is useful when serializing different number types and recursive types.
+//! There is no need to use types for deserialization as the types are available in the Candid message.
+//!
+//! ```
+//! # fn f() -> anyhow::Result<()> {
+//! use candid::{IDLArgs, types::value::IDLValue};
+//! use candid_parser::parse_idl_args;
+//! # use candid::TypeEnv;
+//! # use candid_parser::{IDLProg, check_prog};
+//! # let did_file = r#"
+//! #    type List = opt record { head: int; tail: List };
+//! #    type byte = nat8;
+//! #    service : {
+//! #      f : (byte, int, nat, int8) -> (List);
+//! #      g : (List) -> (int) query;
+//! #    }
+//! # "#;
+//! # let ast = did_file.parse::<IDLProg>()?;
+//! # let mut env = TypeEnv::new();
+//! # let actor = check_prog(&mut env, &ast)?.unwrap();
+//! // Get method type f : (byte, int, nat, int8) -> (List)
+//! let method = env.get_method(&actor, "f").unwrap();
+//! let args = parse_idl_args("(42, 42, 42, 42)")?;
+//! // Serialize arguments with candid types
+//! let encoded = args.to_bytes_with_types(&env, &method.args)?;
+//! let decoded = IDLArgs::from_bytes(&encoded)?;
+//! assert_eq!(decoded.args,
+//!        vec![IDLValue::Nat8(42),
+//!             IDLValue::Int(42.into()),
+//!             IDLValue::Nat(42u8.into()),
+//!             IDLValue::Int8(42)
+//!            ]);
+//! # Ok(())
+//! # }
+//! ```
+
+// only enables the `doc_cfg` feature when
+// the `docsrs` configuration attribute is defined
+#![cfg_attr(docsrs, feature(doc_cfg))]
+
+pub mod error;
+pub use error::{pretty_parse, Error, Result};
+
+pub mod bindings;
+pub mod grammar;
+pub mod token;
+pub mod types;
+pub mod utils;
+pub use types::IDLProg;
+pub mod typing;
+pub use typing::{check_file, check_prog, pretty_check_file};
+
+pub use candid;
+pub use candid::*;
+
+#[cfg_attr(docsrs, doc(cfg(feature = "configs")))]
+#[cfg(feature = "configs")]
+pub mod configs;
+#[cfg_attr(docsrs, doc(cfg(feature = "random")))]
+#[cfg(feature = "random")]
+pub mod random;
+pub mod test;
+
+pub fn parse_idl_args(s: &str) -> crate::Result<candid::IDLArgs> {
+    let lexer = token::Tokenizer::new(s);
+    Ok(grammar::ArgsParser::new().parse(lexer)?)
+}
+
+pub fn parse_idl_value(s: &str) -> crate::Result<candid::IDLValue> {
+    let lexer = token::Tokenizer::new(s);
+    Ok(grammar::ArgParser::new().parse(lexer)?)
+}
diff --git a/rust/candid/src/parser/random.rs b/rust/candid_parser/src/random.rs
similarity index 82%
rename from rust/candid/src/parser/random.rs
rename to rust/candid_parser/src/random.rs
index 79ce9019..de8bd428 100644
--- a/rust/candid/src/parser/random.rs
+++ b/rust/candid_parser/src/random.rs
@@ -1,9 +1,9 @@
 use super::configs::{path_name, Configs};
-use crate::types::value::{IDLArgs, IDLField, IDLValue, VariantValue};
-use crate::types::{Field, Type, TypeEnv, TypeInner};
-use crate::Deserialize;
 use crate::{Error, Result};
 use arbitrary::{unstructured::Int, Arbitrary, Unstructured};
+use candid::types::value::{IDLArgs, IDLField, IDLValue, VariantValue};
+use candid::types::{Field, Type, TypeEnv, TypeInner};
+use candid::Deserialize;
 use std::collections::HashSet;
 use std::convert::TryFrom;
 
@@ -115,7 +115,7 @@ impl<'a> GenState<'a> {
         assert!(self.config.depth.is_none());
         if let Some(vec) = &self.config.value {
             let v = u.choose(vec)?;
-            let v = v.parse::<IDLValue>()?;
+            let v: IDLValue = super::parse_idl_value(v)?;
             let v = v.annotate_type(true, self.env, ty)?;
             self.pop_state(old_config, ty, false);
             return Ok(v);
@@ -140,7 +140,6 @@ impl<'a> GenState<'a> {
             TypeInner::Int64 => IDLValue::Int64(arbitrary_num(u, self.config.range)?),
             TypeInner::Float32 => IDLValue::Float32(u.arbitrary()?),
             TypeInner::Float64 => IDLValue::Float64(u.arbitrary()?),
-            TypeInner::Principal => IDLValue::Principal(crate::Principal::anonymous()),
             TypeInner::Text => {
                 IDLValue::Text(arbitrary_text(u, &self.config.text, &self.config.width)?)
             }
@@ -148,7 +147,7 @@ impl<'a> GenState<'a> {
                 let depths = if self.depth <= 0 || self.size <= 0 {
                     [1, 0]
                 } else {
-                    [1, self.env.size(t).unwrap_or(MAX_DEPTH)]
+                    [1, size(self.env, t).unwrap_or(MAX_DEPTH)]
                 };
                 let idx = arbitrary_variant(u, &depths)?;
                 if idx == 0 {
@@ -159,7 +158,7 @@ impl<'a> GenState<'a> {
             }
             TypeInner::Vec(t) => {
                 let width = self.config.width.or_else(|| {
-                    let elem_size = self.env.size(t).unwrap_or(MAX_DEPTH);
+                    let elem_size = size(self.env, t).unwrap_or(MAX_DEPTH);
                     Some(std::cmp::max(0, self.size) as usize / elem_size)
                 });
                 let len = arbitrary_len(u, width)?;
@@ -186,7 +185,7 @@ impl<'a> GenState<'a> {
             TypeInner::Variant(fs) => {
                 let choices = fs
                     .iter()
-                    .map(|Field { ty, .. }| self.env.size(ty).unwrap_or(MAX_DEPTH));
+                    .map(|Field { ty, .. }| size(self.env, ty).unwrap_or(MAX_DEPTH));
                 let sizes: Vec<_> = if self.depth <= 0 || self.size <= 0 {
                     let min = choices.clone().min().unwrap_or(0);
                     choices.map(|d| if d > min { 0 } else { d }).collect()
@@ -204,6 +203,12 @@ impl<'a> GenState<'a> {
                 };
                 IDLValue::Variant(VariantValue(Box::new(field), idx as u64))
             }
+            TypeInner::Principal => IDLValue::Principal(crate::Principal::arbitrary(u)?),
+            TypeInner::Func(_) => IDLValue::Func(
+                crate::Principal::arbitrary(u)?,
+                arbitrary_text(u, &self.config.text, &self.config.width)?,
+            ),
+            TypeInner::Service(_) => IDLValue::Service(crate::Principal::arbitrary(u)?),
             _ => unimplemented!(),
         });
         self.pop_state(old_config, ty, false);
@@ -211,62 +216,58 @@ impl<'a> GenState<'a> {
     }
 }
 
-impl IDLArgs {
-    pub fn any(seed: &[u8], tree: &Configs, env: &TypeEnv, types: &[Type]) -> Result<Self> {
-        let mut u = arbitrary::Unstructured::new(seed);
-        let mut args = Vec::new();
-        for (i, t) in types.iter().enumerate() {
-            let tree = tree.with_method(&i.to_string());
-            let mut state = GenState::new(&tree, env);
-            let v = state.any(&mut u, t)?;
-            args.push(v);
-        }
-        Ok(IDLArgs { args })
+pub fn any(seed: &[u8], tree: &Configs, env: &TypeEnv, types: &[Type]) -> Result<IDLArgs> {
+    let mut u = arbitrary::Unstructured::new(seed);
+    let mut args = Vec::new();
+    for (i, t) in types.iter().enumerate() {
+        let tree = tree.with_method(&i.to_string());
+        let mut state = GenState::new(&tree, env);
+        let v = state.any(&mut u, t)?;
+        args.push(v);
     }
+    Ok(IDLArgs { args })
 }
 
-impl TypeEnv {
-    /// Approxiamte upper bound for IDLValue size of type t. Returns None if infinite.
-    fn size_helper(&self, seen: &mut HashSet<String>, t: &Type) -> Option<usize> {
-        use TypeInner::*;
-        Some(match t.as_ref() {
-            Var(id) => {
-                if seen.insert(id.to_string()) {
-                    let ty = self.rec_find_type(id).unwrap();
-                    let res = self.size_helper(seen, ty)?;
-                    seen.remove(id);
-                    res
-                } else {
-                    return None;
-                }
+fn size_helper(env: &TypeEnv, seen: &mut HashSet<String>, t: &Type) -> Option<usize> {
+    use TypeInner::*;
+    Some(match t.as_ref() {
+        Var(id) => {
+            if seen.insert(id.to_string()) {
+                let ty = env.rec_find_type(id).unwrap();
+                let res = size_helper(env, seen, ty)?;
+                seen.remove(id);
+                res
+            } else {
+                return None;
             }
-            Empty => 0,
-            Opt(t) => 1 + self.size_helper(seen, t)?,
-            Vec(t) => 1 + self.size_helper(seen, t)? * 2,
-            Record(fs) => {
-                let mut sum = 0;
-                for Field { ty, .. } in fs.iter() {
-                    sum += self.size_helper(seen, ty)?;
-                }
-                1 + sum
+        }
+        Empty => 0,
+        Opt(t) => 1 + size_helper(env, seen, t)?,
+        Vec(t) => 1 + size_helper(env, seen, t)? * 2,
+        Record(fs) => {
+            let mut sum = 0;
+            for Field { ty, .. } in fs.iter() {
+                sum += size_helper(env, seen, ty)?;
             }
-            Variant(fs) => {
-                let mut max = 0;
-                for Field { ty, .. } in fs.iter() {
-                    let s = self.size_helper(seen, ty)?;
-                    if s > max {
-                        max = s;
-                    };
-                }
-                1 + max
+            1 + sum
+        }
+        Variant(fs) => {
+            let mut max = 0;
+            for Field { ty, .. } in fs.iter() {
+                let s = size_helper(env, seen, ty)?;
+                if s > max {
+                    max = s;
+                };
             }
-            _ => 1,
-        })
-    }
-    fn size(&self, t: &Type) -> Option<usize> {
-        let mut seen = HashSet::new();
-        self.size_helper(&mut seen, t)
-    }
+            1 + max
+        }
+        _ => 1,
+    })
+}
+
+fn size(env: &TypeEnv, t: &Type) -> Option<usize> {
+    let mut seen = HashSet::new();
+    size_helper(env, &mut seen, t)
 }
 
 fn choose_range<T: Int>(u: &mut Unstructured, ranges: &[std::ops::RangeInclusive<T>]) -> Result<T> {
diff --git a/rust/candid/src/parser/test.rs b/rust/candid_parser/src/test.rs
similarity index 95%
rename from rust/candid/src/parser/test.rs
rename to rust/candid_parser/src/test.rs
index 7fefd6d1..f48c2ac4 100644
--- a/rust/candid/src/parser/test.rs
+++ b/rust/candid_parser/src/test.rs
@@ -1,8 +1,8 @@
 use super::types::{Dec, IDLProg, IDLType};
 use super::typing::check_prog;
-use crate::types::value::IDLArgs;
-use crate::types::{Type, TypeEnv};
 use crate::{Error, Result};
+use candid::types::value::IDLArgs;
+use candid::types::{Type, TypeEnv};
 
 type TupType = Vec<IDLType>;
 
@@ -50,7 +50,7 @@ impl Assert {
 impl Input {
     pub fn parse(&self, env: &TypeEnv, types: &[Type]) -> Result<IDLArgs> {
         match self {
-            Input::Text(ref s) => s.parse::<IDLArgs>()?.annotate_types(true, env, types),
+            Input::Text(ref s) => Ok(super::parse_idl_args(s)?.annotate_types(true, env, types)?),
             Input::Blob(ref bytes) => Ok(IDLArgs::from_bytes_with_types(bytes, env, types)?),
         }
     }
@@ -82,7 +82,7 @@ impl HostTest {
             Input::Text(s) => {
                 // Without type annotation, numbers are all of type int.
                 // Assertion may not pass.
-                let parsed = s.parse::<IDLArgs>();
+                let parsed = crate::parse_idl_args(s);
                 if parsed.is_err() {
                     let desc = format!("(skip) {}", assert.desc());
                     return HostTest { desc, asserts };
@@ -145,7 +145,7 @@ pub fn check(test: Test) -> Result<()> {
         print!("Checking {} {}...", i + 1, assert.desc());
         let mut types = Vec::new();
         for ty in assert.typ.iter() {
-            types.push(env.ast_to_type(ty)?);
+            types.push(super::typing::ast_to_type(&env, ty)?);
         }
         let input = assert.left.parse(&env, &types);
         let pass = if let Some(assert_right) = &assert.right {
diff --git a/rust/candid/src/parser/token.rs b/rust/candid_parser/src/token.rs
similarity index 100%
rename from rust/candid/src/parser/token.rs
rename to rust/candid_parser/src/token.rs
diff --git a/rust/candid/src/parser/types.rs b/rust/candid_parser/src/types.rs
similarity index 98%
rename from rust/candid/src/parser/types.rs
rename to rust/candid_parser/src/types.rs
index 5c9794f6..70861704 100644
--- a/rust/candid/src/parser/types.rs
+++ b/rust/candid_parser/src/types.rs
@@ -1,5 +1,5 @@
-use crate::types::{FuncMode, Label};
 use crate::Result;
+use candid::types::{FuncMode, Label};
 
 #[derive(Debug, Clone)]
 pub enum IDLType {
diff --git a/rust/candid/src/parser/typing.rs b/rust/candid_parser/src/typing.rs
similarity index 95%
rename from rust/candid/src/parser/typing.rs
rename to rust/candid_parser/src/typing.rs
index 1b126d59..60bd26ba 100644
--- a/rust/candid/src/parser/typing.rs
+++ b/rust/candid_parser/src/typing.rs
@@ -1,6 +1,6 @@
 use super::types::*;
-use crate::types::{Field, Function, Type, TypeEnv, TypeInner};
 use crate::{pretty_parse, Error, Result};
+use candid::types::{Field, Function, Type, TypeEnv, TypeInner};
 use std::collections::BTreeSet;
 use std::path::{Path, PathBuf};
 
@@ -9,15 +9,13 @@ pub struct Env<'a> {
     pub pre: bool,
 }
 
-impl TypeEnv {
-    /// Convert candid AST to internal Type
-    pub fn ast_to_type(&self, ast: &super::types::IDLType) -> Result<Type> {
-        let env = Env {
-            te: &mut self.clone(),
-            pre: false,
-        };
-        check_type(&env, ast)
-    }
+/// Convert candid AST to internal Type
+pub fn ast_to_type(env: &TypeEnv, ast: &super::types::IDLType) -> Result<Type> {
+    let env = Env {
+        te: &mut env.clone(),
+        pre: false,
+    };
+    check_type(&env, ast)
 }
 
 fn check_prim(prim: &PrimType) -> Type {
@@ -80,7 +78,7 @@ pub fn check_type(env: &Env, t: &IDLType) -> Result<Type> {
                 return Err(Error::msg("cannot have more than one mode"));
             }
             if func.modes.len() == 1
-                && func.modes[0] == crate::types::FuncMode::Oneway
+                && func.modes[0] == candid::types::FuncMode::Oneway
                 && !t2.is_empty()
             {
                 return Err(Error::msg("oneway function has non-unit return type"));
diff --git a/rust/candid_parser/src/utils.rs b/rust/candid_parser/src/utils.rs
new file mode 100644
index 00000000..82a1b32c
--- /dev/null
+++ b/rust/candid_parser/src/utils.rs
@@ -0,0 +1,82 @@
+use crate::{check_prog, pretty_check_file, pretty_parse, Error, Result};
+use candid::{types::Type, TypeEnv};
+use std::path::Path;
+
+pub enum CandidSource<'a> {
+    File(&'a Path),
+    Text(&'a str),
+}
+
+impl<'a> CandidSource<'a> {
+    pub fn load(&self) -> Result<(TypeEnv, Option<Type>)> {
+        Ok(match self {
+            CandidSource::File(path) => pretty_check_file(path)?,
+            CandidSource::Text(str) => {
+                let ast = pretty_parse("", str)?;
+                let mut env = TypeEnv::new();
+                let actor = check_prog(&mut env, &ast)?;
+                (env, actor)
+            }
+        })
+    }
+}
+
+/// Check compatibility of two service types
+pub fn service_compatible(new: CandidSource, old: CandidSource) -> Result<()> {
+    let (mut env, t1) = new.load()?;
+    let t1 = t1.ok_or_else(|| Error::msg("new interface has no main service type"))?;
+    let (env2, t2) = old.load()?;
+    let t2 = t2.ok_or_else(|| Error::msg("old interface has no main service type"))?;
+    let mut gamma = std::collections::HashSet::new();
+    let t2 = env.merge_type(env2, t2);
+    candid::types::subtype::subtype(&mut gamma, &env, &t1, &t2)?;
+    Ok(())
+}
+
+/// Check structural equality of two service types
+pub fn service_equal(left: CandidSource, right: CandidSource) -> Result<()> {
+    let (mut env, t1) = left.load()?;
+    let t1 = t1.ok_or_else(|| Error::msg("left interface has no main service type"))?;
+    let (env2, t2) = right.load()?;
+    let t2 = t2.ok_or_else(|| Error::msg("right interface has no main service type"))?;
+    let mut gamma = std::collections::HashSet::new();
+    let t2 = env.merge_type(env2, t2);
+    candid::types::subtype::equal(&mut gamma, &env, &t1, &t2)?;
+    Ok(())
+}
+
+/// Take a did file and outputs the init args and the service type (without init args).
+/// If the original did file contains imports, the output flattens the type definitions.
+/// For now, the comments from the original did file is omitted.
+pub fn instantiate_candid(candid: CandidSource) -> Result<(Vec<Type>, (TypeEnv, Type))> {
+    use candid::types::TypeInner;
+    let (env, serv) = candid.load()?;
+    let serv = serv.ok_or_else(|| Error::msg("the Candid interface has no main service type"))?;
+    let serv = env.trace_type(&serv)?;
+    Ok(match serv.as_ref() {
+        TypeInner::Class(args, ty) => (args.clone(), (env, ty.clone())),
+        TypeInner::Service(_) => (vec![], (env, serv)),
+        _ => unreachable!(),
+    })
+}
+
+/// Merge canister metadata candid:args and candid:service into a service constructor.
+/// If candid:service already contains init args, returns the original did file.
+pub fn merge_init_args(candid: &str, init: &str) -> Result<(TypeEnv, Type)> {
+    use crate::{types::IDLInitArgs, typing::check_init_args};
+    use candid::types::TypeInner;
+    let candid = CandidSource::Text(candid);
+    let (env, serv) = candid.load()?;
+    let serv = serv.ok_or_else(|| Error::msg("the Candid interface has no main service type"))?;
+    let serv = env.trace_type(&serv)?;
+    match serv.as_ref() {
+        TypeInner::Class(_, _) => Ok((env, serv)),
+        TypeInner::Service(_) => {
+            let prog = init.parse::<IDLInitArgs>()?;
+            let mut env2 = TypeEnv::new();
+            let args = check_init_args(&mut env2, &env, &prog)?;
+            Ok((env2, TypeInner::Class(args, serv).into()))
+        }
+        _ => unreachable!(),
+    }
+}
diff --git a/rust/candid/tests/assets/actor.did b/rust/candid_parser/tests/assets/actor.did
similarity index 100%
rename from rust/candid/tests/assets/actor.did
rename to rust/candid_parser/tests/assets/actor.did
diff --git a/rust/candid/tests/assets/bad_comment.did b/rust/candid_parser/tests/assets/bad_comment.did
similarity index 100%
rename from rust/candid/tests/assets/bad_comment.did
rename to rust/candid_parser/tests/assets/bad_comment.did
diff --git a/rust/candid/tests/assets/bad_import.did b/rust/candid_parser/tests/assets/bad_import.did
similarity index 100%
rename from rust/candid/tests/assets/bad_import.did
rename to rust/candid_parser/tests/assets/bad_import.did
diff --git a/rust/candid/tests/assets/class.did b/rust/candid_parser/tests/assets/class.did
similarity index 100%
rename from rust/candid/tests/assets/class.did
rename to rust/candid_parser/tests/assets/class.did
diff --git a/rust/candid/tests/assets/codegen/basic/invalid_id.did b/rust/candid_parser/tests/assets/codegen/basic/invalid_id.did
similarity index 100%
rename from rust/candid/tests/assets/codegen/basic/invalid_id.did
rename to rust/candid_parser/tests/assets/codegen/basic/invalid_id.did
diff --git a/rust/candid/tests/assets/codegen/basic/invalid_id.rs b/rust/candid_parser/tests/assets/codegen/basic/invalid_id.rs
similarity index 100%
rename from rust/candid/tests/assets/codegen/basic/invalid_id.rs
rename to rust/candid_parser/tests/assets/codegen/basic/invalid_id.rs
diff --git a/rust/candid/tests/assets/codegen/basic/prim_types.did b/rust/candid_parser/tests/assets/codegen/basic/prim_types.did
similarity index 100%
rename from rust/candid/tests/assets/codegen/basic/prim_types.did
rename to rust/candid_parser/tests/assets/codegen/basic/prim_types.did
diff --git a/rust/candid/tests/assets/codegen/basic/prim_types.rs b/rust/candid_parser/tests/assets/codegen/basic/prim_types.rs
similarity index 100%
rename from rust/candid/tests/assets/codegen/basic/prim_types.rs
rename to rust/candid_parser/tests/assets/codegen/basic/prim_types.rs
diff --git a/rust/candid/tests/assets/codegen/basic/recursive.did b/rust/candid_parser/tests/assets/codegen/basic/recursive.did
similarity index 100%
rename from rust/candid/tests/assets/codegen/basic/recursive.did
rename to rust/candid_parser/tests/assets/codegen/basic/recursive.did
diff --git a/rust/candid/tests/assets/codegen/basic/recursive.rs b/rust/candid_parser/tests/assets/codegen/basic/recursive.rs
similarity index 100%
rename from rust/candid/tests/assets/codegen/basic/recursive.rs
rename to rust/candid_parser/tests/assets/codegen/basic/recursive.rs
diff --git a/rust/candid/tests/assets/codegen/examples/linkedup.did b/rust/candid_parser/tests/assets/codegen/examples/linkedup.did
similarity index 100%
rename from rust/candid/tests/assets/codegen/examples/linkedup.did
rename to rust/candid_parser/tests/assets/codegen/examples/linkedup.did
diff --git a/rust/candid/tests/assets/codegen/examples/linkedup.rs b/rust/candid_parser/tests/assets/codegen/examples/linkedup.rs
similarity index 100%
rename from rust/candid/tests/assets/codegen/examples/linkedup.rs
rename to rust/candid_parser/tests/assets/codegen/examples/linkedup.rs
diff --git a/rust/candid/tests/assets/collision_fields.did b/rust/candid_parser/tests/assets/collision_fields.did
similarity index 100%
rename from rust/candid/tests/assets/collision_fields.did
rename to rust/candid_parser/tests/assets/collision_fields.did
diff --git a/rust/candid/tests/assets/collision_fields2.did b/rust/candid_parser/tests/assets/collision_fields2.did
similarity index 100%
rename from rust/candid/tests/assets/collision_fields2.did
rename to rust/candid_parser/tests/assets/collision_fields2.did
diff --git a/rust/candid/tests/assets/comment.did b/rust/candid_parser/tests/assets/comment.did
similarity index 100%
rename from rust/candid/tests/assets/comment.did
rename to rust/candid_parser/tests/assets/comment.did
diff --git a/rust/candid/tests/assets/cyclic.did b/rust/candid_parser/tests/assets/cyclic.did
similarity index 100%
rename from rust/candid/tests/assets/cyclic.did
rename to rust/candid_parser/tests/assets/cyclic.did
diff --git a/rust/candid_parser/tests/assets/empty.did b/rust/candid_parser/tests/assets/empty.did
new file mode 100644
index 00000000..30c83f1b
--- /dev/null
+++ b/rust/candid_parser/tests/assets/empty.did
@@ -0,0 +1,6 @@
+type T = record { T };
+service : {
+  f : (record {}) -> (variant {});
+  g : (T) -> (variant {a:T});
+  h : (record {T; empty}) -> (variant {a:T; b:record {}});
+}
diff --git a/rust/candid/tests/assets/escape.did b/rust/candid_parser/tests/assets/escape.did
similarity index 100%
rename from rust/candid/tests/assets/escape.did
rename to rust/candid_parser/tests/assets/escape.did
diff --git a/rust/candid/tests/assets/example.did b/rust/candid_parser/tests/assets/example.did
similarity index 100%
rename from rust/candid/tests/assets/example.did
rename to rust/candid_parser/tests/assets/example.did
diff --git a/rust/candid/tests/assets/fieldnat.did b/rust/candid_parser/tests/assets/fieldnat.did
similarity index 100%
rename from rust/candid/tests/assets/fieldnat.did
rename to rust/candid_parser/tests/assets/fieldnat.did
diff --git a/rust/candid/tests/assets/import/a.did b/rust/candid_parser/tests/assets/import/a.did
similarity index 100%
rename from rust/candid/tests/assets/import/a.did
rename to rust/candid_parser/tests/assets/import/a.did
diff --git a/rust/candid/tests/assets/import/b/b.did b/rust/candid_parser/tests/assets/import/b/b.did
similarity index 100%
rename from rust/candid/tests/assets/import/b/b.did
rename to rust/candid_parser/tests/assets/import/b/b.did
diff --git a/rust/candid/tests/assets/invalid_cyclic.did b/rust/candid_parser/tests/assets/invalid_cyclic.did
similarity index 100%
rename from rust/candid/tests/assets/invalid_cyclic.did
rename to rust/candid_parser/tests/assets/invalid_cyclic.did
diff --git a/rust/candid/tests/assets/keyword.did b/rust/candid_parser/tests/assets/keyword.did
similarity index 100%
rename from rust/candid/tests/assets/keyword.did
rename to rust/candid_parser/tests/assets/keyword.did
diff --git a/rust/candid/tests/assets/management.did b/rust/candid_parser/tests/assets/management.did
similarity index 100%
rename from rust/candid/tests/assets/management.did
rename to rust/candid_parser/tests/assets/management.did
diff --git a/rust/candid/tests/assets/not_func.did b/rust/candid_parser/tests/assets/not_func.did
similarity index 100%
rename from rust/candid/tests/assets/not_func.did
rename to rust/candid_parser/tests/assets/not_func.did
diff --git a/rust/candid/tests/assets/not_serv.did b/rust/candid_parser/tests/assets/not_serv.did
similarity index 100%
rename from rust/candid/tests/assets/not_serv.did
rename to rust/candid_parser/tests/assets/not_serv.did
diff --git a/rust/candid/tests/assets/ok/actor.d.ts b/rust/candid_parser/tests/assets/ok/actor.d.ts
similarity index 100%
rename from rust/candid/tests/assets/ok/actor.d.ts
rename to rust/candid_parser/tests/assets/ok/actor.d.ts
diff --git a/rust/candid/tests/assets/ok/actor.did b/rust/candid_parser/tests/assets/ok/actor.did
similarity index 100%
rename from rust/candid/tests/assets/ok/actor.did
rename to rust/candid_parser/tests/assets/ok/actor.did
diff --git a/rust/candid/tests/assets/ok/actor.js b/rust/candid_parser/tests/assets/ok/actor.js
similarity index 100%
rename from rust/candid/tests/assets/ok/actor.js
rename to rust/candid_parser/tests/assets/ok/actor.js
diff --git a/rust/candid/tests/assets/ok/actor.mo b/rust/candid_parser/tests/assets/ok/actor.mo
similarity index 100%
rename from rust/candid/tests/assets/ok/actor.mo
rename to rust/candid_parser/tests/assets/ok/actor.mo
diff --git a/rust/candid/tests/assets/ok/actor.rs b/rust/candid_parser/tests/assets/ok/actor.rs
similarity index 100%
rename from rust/candid/tests/assets/ok/actor.rs
rename to rust/candid_parser/tests/assets/ok/actor.rs
diff --git a/rust/candid/tests/assets/ok/bad_comment.fail b/rust/candid_parser/tests/assets/ok/bad_comment.fail
similarity index 100%
rename from rust/candid/tests/assets/ok/bad_comment.fail
rename to rust/candid_parser/tests/assets/ok/bad_comment.fail
diff --git a/rust/candid/tests/assets/ok/bad_import.fail b/rust/candid_parser/tests/assets/ok/bad_import.fail
similarity index 100%
rename from rust/candid/tests/assets/ok/bad_import.fail
rename to rust/candid_parser/tests/assets/ok/bad_import.fail
diff --git a/rust/candid/tests/assets/ok/class.d.ts b/rust/candid_parser/tests/assets/ok/class.d.ts
similarity index 100%
rename from rust/candid/tests/assets/ok/class.d.ts
rename to rust/candid_parser/tests/assets/ok/class.d.ts
diff --git a/rust/candid/tests/assets/ok/class.did b/rust/candid_parser/tests/assets/ok/class.did
similarity index 100%
rename from rust/candid/tests/assets/ok/class.did
rename to rust/candid_parser/tests/assets/ok/class.did
diff --git a/rust/candid/tests/assets/ok/class.js b/rust/candid_parser/tests/assets/ok/class.js
similarity index 100%
rename from rust/candid/tests/assets/ok/class.js
rename to rust/candid_parser/tests/assets/ok/class.js
diff --git a/rust/candid/tests/assets/ok/class.mo b/rust/candid_parser/tests/assets/ok/class.mo
similarity index 100%
rename from rust/candid/tests/assets/ok/class.mo
rename to rust/candid_parser/tests/assets/ok/class.mo
diff --git a/rust/candid/tests/assets/ok/class.rs b/rust/candid_parser/tests/assets/ok/class.rs
similarity index 100%
rename from rust/candid/tests/assets/ok/class.rs
rename to rust/candid_parser/tests/assets/ok/class.rs
diff --git a/rust/candid/tests/assets/ok/collision_fields.fail b/rust/candid_parser/tests/assets/ok/collision_fields.fail
similarity index 100%
rename from rust/candid/tests/assets/ok/collision_fields.fail
rename to rust/candid_parser/tests/assets/ok/collision_fields.fail
diff --git a/rust/candid/tests/assets/ok/collision_fields2.fail b/rust/candid_parser/tests/assets/ok/collision_fields2.fail
similarity index 100%
rename from rust/candid/tests/assets/ok/collision_fields2.fail
rename to rust/candid_parser/tests/assets/ok/collision_fields2.fail
diff --git a/rust/candid/tests/assets/ok/comment.d.ts b/rust/candid_parser/tests/assets/ok/comment.d.ts
similarity index 100%
rename from rust/candid/tests/assets/ok/comment.d.ts
rename to rust/candid_parser/tests/assets/ok/comment.d.ts
diff --git a/rust/candid/tests/assets/ok/comment.did b/rust/candid_parser/tests/assets/ok/comment.did
similarity index 100%
rename from rust/candid/tests/assets/ok/comment.did
rename to rust/candid_parser/tests/assets/ok/comment.did
diff --git a/rust/candid/tests/assets/ok/comment.js b/rust/candid_parser/tests/assets/ok/comment.js
similarity index 100%
rename from rust/candid/tests/assets/ok/comment.js
rename to rust/candid_parser/tests/assets/ok/comment.js
diff --git a/rust/candid/tests/assets/ok/comment.mo b/rust/candid_parser/tests/assets/ok/comment.mo
similarity index 100%
rename from rust/candid/tests/assets/ok/comment.mo
rename to rust/candid_parser/tests/assets/ok/comment.mo
diff --git a/rust/candid/tests/assets/ok/comment.rs b/rust/candid_parser/tests/assets/ok/comment.rs
similarity index 100%
rename from rust/candid/tests/assets/ok/comment.rs
rename to rust/candid_parser/tests/assets/ok/comment.rs
diff --git a/rust/candid/tests/assets/ok/cyclic.d.ts b/rust/candid_parser/tests/assets/ok/cyclic.d.ts
similarity index 100%
rename from rust/candid/tests/assets/ok/cyclic.d.ts
rename to rust/candid_parser/tests/assets/ok/cyclic.d.ts
diff --git a/rust/candid/tests/assets/ok/cyclic.did b/rust/candid_parser/tests/assets/ok/cyclic.did
similarity index 100%
rename from rust/candid/tests/assets/ok/cyclic.did
rename to rust/candid_parser/tests/assets/ok/cyclic.did
diff --git a/rust/candid/tests/assets/ok/cyclic.js b/rust/candid_parser/tests/assets/ok/cyclic.js
similarity index 100%
rename from rust/candid/tests/assets/ok/cyclic.js
rename to rust/candid_parser/tests/assets/ok/cyclic.js
diff --git a/rust/candid/tests/assets/ok/cyclic.mo b/rust/candid_parser/tests/assets/ok/cyclic.mo
similarity index 100%
rename from rust/candid/tests/assets/ok/cyclic.mo
rename to rust/candid_parser/tests/assets/ok/cyclic.mo
diff --git a/rust/candid/tests/assets/ok/cyclic.rs b/rust/candid_parser/tests/assets/ok/cyclic.rs
similarity index 100%
rename from rust/candid/tests/assets/ok/cyclic.rs
rename to rust/candid_parser/tests/assets/ok/cyclic.rs
diff --git a/rust/candid_parser/tests/assets/ok/empty.d.ts b/rust/candid_parser/tests/assets/ok/empty.d.ts
new file mode 100644
index 00000000..4d42e33e
--- /dev/null
+++ b/rust/candid_parser/tests/assets/ok/empty.d.ts
@@ -0,0 +1,11 @@
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+import type { IDL } from '@dfinity/candid';
+
+export type T = [T];
+export interface _SERVICE {
+  'f' : ActorMethod<[{}], never>,
+  'g' : ActorMethod<[T], { 'a' : T }>,
+  'h' : ActorMethod<[[T, never]], { 'a' : T } | { 'b' : {} }>,
+}
+export declare const idlFactory: IDL.InterfaceFactory;
diff --git a/rust/candid_parser/tests/assets/ok/empty.did b/rust/candid_parser/tests/assets/ok/empty.did
new file mode 100644
index 00000000..9f45b1d9
--- /dev/null
+++ b/rust/candid_parser/tests/assets/ok/empty.did
@@ -0,0 +1,6 @@
+type T = record { T };
+service : {
+  f : (record {}) -> (variant {});
+  g : (T) -> (variant { a : T });
+  h : (record { T; empty }) -> (variant { a : T; b : record {} });
+}
diff --git a/rust/candid_parser/tests/assets/ok/empty.js b/rust/candid_parser/tests/assets/ok/empty.js
new file mode 100644
index 00000000..74b91c7c
--- /dev/null
+++ b/rust/candid_parser/tests/assets/ok/empty.js
@@ -0,0 +1,14 @@
+export const idlFactory = ({ IDL }) => {
+  const T = IDL.Rec();
+  T.fill(IDL.Tuple(T));
+  return IDL.Service({
+    'f' : IDL.Func([IDL.Record({})], [IDL.Variant({})], []),
+    'g' : IDL.Func([T], [IDL.Variant({ 'a' : T })], []),
+    'h' : IDL.Func(
+        [IDL.Tuple(T, IDL.Empty)],
+        [IDL.Variant({ 'a' : T, 'b' : IDL.Record({}) })],
+        [],
+      ),
+  });
+};
+export const init = ({ IDL }) => { return []; };
diff --git a/rust/candid_parser/tests/assets/ok/empty.mo b/rust/candid_parser/tests/assets/ok/empty.mo
new file mode 100644
index 00000000..0a7b5904
--- /dev/null
+++ b/rust/candid_parser/tests/assets/ok/empty.mo
@@ -0,0 +1,11 @@
+// This is a generated Motoko binding.
+// Please use `import service "ic:canister_id"` instead to call canisters on the IC if possible.
+
+module {
+  public type T = { _0_  : T };
+  public type Self = actor {
+    f : shared {} -> async {#};
+    g : shared T -> async { #a : T };
+    h : shared ((T, None)) -> async { #a : T; #b : {} };
+  }
+}
diff --git a/rust/candid_parser/tests/assets/ok/empty.rs b/rust/candid_parser/tests/assets/ok/empty.rs
new file mode 100644
index 00000000..ee1eed61
--- /dev/null
+++ b/rust/candid_parser/tests/assets/ok/empty.rs
@@ -0,0 +1,35 @@
+// This is an experimental feature to generate Rust binding from Candid.
+// You may want to manually adjust some of the types.
+#![allow(dead_code, unused_imports)]
+use candid::{self, CandidType, Deserialize, Principal, Encode, Decode};
+use ic_cdk::api::call::CallResult as Result;
+
+#[derive(CandidType, Deserialize)]
+pub struct FArg {}
+
+#[derive(CandidType, Deserialize)]
+pub enum FRet {}
+
+#[derive(CandidType, Deserialize)]
+pub struct T (pub Box<T>,);
+
+#[derive(CandidType, Deserialize)]
+pub enum GRet { #[serde(rename="a")] A(Box<T>) }
+
+#[derive(CandidType, Deserialize)]
+pub enum HRet { #[serde(rename="a")] A(Box<T>), #[serde(rename="b")] B{} }
+
+pub struct Service(pub Principal);
+impl Service {
+  pub async fn f(&self, arg0: FArg) -> Result<(FRet,)> {
+    ic_cdk::call(self.0, "f", (arg0,)).await
+  }
+  pub async fn g(&self, arg0: T) -> Result<(GRet,)> {
+    ic_cdk::call(self.0, "g", (arg0,)).await
+  }
+  pub async fn h(&self, arg0: (T,candid::Empty,)) -> Result<(HRet,)> {
+    ic_cdk::call(self.0, "h", (arg0,)).await
+  }
+}
+pub const CANISTER_ID : Principal = Principal::from_slice(&[]); // aaaaa-aa
+pub const service : Service = Service(CANISTER_ID);
diff --git a/rust/candid/tests/assets/ok/escape.d.ts b/rust/candid_parser/tests/assets/ok/escape.d.ts
similarity index 100%
rename from rust/candid/tests/assets/ok/escape.d.ts
rename to rust/candid_parser/tests/assets/ok/escape.d.ts
diff --git a/rust/candid/tests/assets/ok/escape.did b/rust/candid_parser/tests/assets/ok/escape.did
similarity index 100%
rename from rust/candid/tests/assets/ok/escape.did
rename to rust/candid_parser/tests/assets/ok/escape.did
diff --git a/rust/candid/tests/assets/ok/escape.js b/rust/candid_parser/tests/assets/ok/escape.js
similarity index 100%
rename from rust/candid/tests/assets/ok/escape.js
rename to rust/candid_parser/tests/assets/ok/escape.js
diff --git a/rust/candid/tests/assets/ok/escape.rs b/rust/candid_parser/tests/assets/ok/escape.rs
similarity index 100%
rename from rust/candid/tests/assets/ok/escape.rs
rename to rust/candid_parser/tests/assets/ok/escape.rs
diff --git a/rust/candid/tests/assets/ok/example.d.ts b/rust/candid_parser/tests/assets/ok/example.d.ts
similarity index 100%
rename from rust/candid/tests/assets/ok/example.d.ts
rename to rust/candid_parser/tests/assets/ok/example.d.ts
diff --git a/rust/candid/tests/assets/ok/example.did b/rust/candid_parser/tests/assets/ok/example.did
similarity index 100%
rename from rust/candid/tests/assets/ok/example.did
rename to rust/candid_parser/tests/assets/ok/example.did
diff --git a/rust/candid/tests/assets/ok/example.js b/rust/candid_parser/tests/assets/ok/example.js
similarity index 100%
rename from rust/candid/tests/assets/ok/example.js
rename to rust/candid_parser/tests/assets/ok/example.js
diff --git a/rust/candid/tests/assets/ok/example.mo b/rust/candid_parser/tests/assets/ok/example.mo
similarity index 100%
rename from rust/candid/tests/assets/ok/example.mo
rename to rust/candid_parser/tests/assets/ok/example.mo
diff --git a/rust/candid/tests/assets/ok/example.rs b/rust/candid_parser/tests/assets/ok/example.rs
similarity index 100%
rename from rust/candid/tests/assets/ok/example.rs
rename to rust/candid_parser/tests/assets/ok/example.rs
diff --git a/rust/candid/tests/assets/ok/fieldnat.d.ts b/rust/candid_parser/tests/assets/ok/fieldnat.d.ts
similarity index 100%
rename from rust/candid/tests/assets/ok/fieldnat.d.ts
rename to rust/candid_parser/tests/assets/ok/fieldnat.d.ts
diff --git a/rust/candid/tests/assets/ok/fieldnat.did b/rust/candid_parser/tests/assets/ok/fieldnat.did
similarity index 100%
rename from rust/candid/tests/assets/ok/fieldnat.did
rename to rust/candid_parser/tests/assets/ok/fieldnat.did
diff --git a/rust/candid/tests/assets/ok/fieldnat.js b/rust/candid_parser/tests/assets/ok/fieldnat.js
similarity index 100%
rename from rust/candid/tests/assets/ok/fieldnat.js
rename to rust/candid_parser/tests/assets/ok/fieldnat.js
diff --git a/rust/candid/tests/assets/ok/fieldnat.mo b/rust/candid_parser/tests/assets/ok/fieldnat.mo
similarity index 100%
rename from rust/candid/tests/assets/ok/fieldnat.mo
rename to rust/candid_parser/tests/assets/ok/fieldnat.mo
diff --git a/rust/candid/tests/assets/ok/fieldnat.rs b/rust/candid_parser/tests/assets/ok/fieldnat.rs
similarity index 100%
rename from rust/candid/tests/assets/ok/fieldnat.rs
rename to rust/candid_parser/tests/assets/ok/fieldnat.rs
diff --git a/rust/candid/tests/assets/ok/invalid_cyclic.fail b/rust/candid_parser/tests/assets/ok/invalid_cyclic.fail
similarity index 100%
rename from rust/candid/tests/assets/ok/invalid_cyclic.fail
rename to rust/candid_parser/tests/assets/ok/invalid_cyclic.fail
diff --git a/rust/candid/tests/assets/ok/keyword.d.ts b/rust/candid_parser/tests/assets/ok/keyword.d.ts
similarity index 100%
rename from rust/candid/tests/assets/ok/keyword.d.ts
rename to rust/candid_parser/tests/assets/ok/keyword.d.ts
diff --git a/rust/candid/tests/assets/ok/keyword.did b/rust/candid_parser/tests/assets/ok/keyword.did
similarity index 100%
rename from rust/candid/tests/assets/ok/keyword.did
rename to rust/candid_parser/tests/assets/ok/keyword.did
diff --git a/rust/candid/tests/assets/ok/keyword.js b/rust/candid_parser/tests/assets/ok/keyword.js
similarity index 100%
rename from rust/candid/tests/assets/ok/keyword.js
rename to rust/candid_parser/tests/assets/ok/keyword.js
diff --git a/rust/candid/tests/assets/ok/keyword.mo b/rust/candid_parser/tests/assets/ok/keyword.mo
similarity index 100%
rename from rust/candid/tests/assets/ok/keyword.mo
rename to rust/candid_parser/tests/assets/ok/keyword.mo
diff --git a/rust/candid/tests/assets/ok/keyword.rs b/rust/candid_parser/tests/assets/ok/keyword.rs
similarity index 100%
rename from rust/candid/tests/assets/ok/keyword.rs
rename to rust/candid_parser/tests/assets/ok/keyword.rs
diff --git a/rust/candid/tests/assets/ok/management.d.ts b/rust/candid_parser/tests/assets/ok/management.d.ts
similarity index 100%
rename from rust/candid/tests/assets/ok/management.d.ts
rename to rust/candid_parser/tests/assets/ok/management.d.ts
diff --git a/rust/candid/tests/assets/ok/management.did b/rust/candid_parser/tests/assets/ok/management.did
similarity index 100%
rename from rust/candid/tests/assets/ok/management.did
rename to rust/candid_parser/tests/assets/ok/management.did
diff --git a/rust/candid/tests/assets/ok/management.js b/rust/candid_parser/tests/assets/ok/management.js
similarity index 100%
rename from rust/candid/tests/assets/ok/management.js
rename to rust/candid_parser/tests/assets/ok/management.js
diff --git a/rust/candid/tests/assets/ok/management.mo b/rust/candid_parser/tests/assets/ok/management.mo
similarity index 100%
rename from rust/candid/tests/assets/ok/management.mo
rename to rust/candid_parser/tests/assets/ok/management.mo
diff --git a/rust/candid/tests/assets/ok/management.rs b/rust/candid_parser/tests/assets/ok/management.rs
similarity index 100%
rename from rust/candid/tests/assets/ok/management.rs
rename to rust/candid_parser/tests/assets/ok/management.rs
diff --git a/rust/candid/tests/assets/ok/not_func.fail b/rust/candid_parser/tests/assets/ok/not_func.fail
similarity index 100%
rename from rust/candid/tests/assets/ok/not_func.fail
rename to rust/candid_parser/tests/assets/ok/not_func.fail
diff --git a/rust/candid/tests/assets/ok/not_serv.fail b/rust/candid_parser/tests/assets/ok/not_serv.fail
similarity index 100%
rename from rust/candid/tests/assets/ok/not_serv.fail
rename to rust/candid_parser/tests/assets/ok/not_serv.fail
diff --git a/rust/candid/tests/assets/ok/oneway.fail b/rust/candid_parser/tests/assets/ok/oneway.fail
similarity index 100%
rename from rust/candid/tests/assets/ok/oneway.fail
rename to rust/candid_parser/tests/assets/ok/oneway.fail
diff --git a/rust/candid/tests/assets/ok/recursion.d.ts b/rust/candid_parser/tests/assets/ok/recursion.d.ts
similarity index 100%
rename from rust/candid/tests/assets/ok/recursion.d.ts
rename to rust/candid_parser/tests/assets/ok/recursion.d.ts
diff --git a/rust/candid/tests/assets/ok/recursion.did b/rust/candid_parser/tests/assets/ok/recursion.did
similarity index 100%
rename from rust/candid/tests/assets/ok/recursion.did
rename to rust/candid_parser/tests/assets/ok/recursion.did
diff --git a/rust/candid/tests/assets/ok/recursion.js b/rust/candid_parser/tests/assets/ok/recursion.js
similarity index 100%
rename from rust/candid/tests/assets/ok/recursion.js
rename to rust/candid_parser/tests/assets/ok/recursion.js
diff --git a/rust/candid/tests/assets/ok/recursion.mo b/rust/candid_parser/tests/assets/ok/recursion.mo
similarity index 100%
rename from rust/candid/tests/assets/ok/recursion.mo
rename to rust/candid_parser/tests/assets/ok/recursion.mo
diff --git a/rust/candid/tests/assets/ok/recursion.rs b/rust/candid_parser/tests/assets/ok/recursion.rs
similarity index 100%
rename from rust/candid/tests/assets/ok/recursion.rs
rename to rust/candid_parser/tests/assets/ok/recursion.rs
diff --git a/rust/candid/tests/assets/ok/recursive_class.d.ts b/rust/candid_parser/tests/assets/ok/recursive_class.d.ts
similarity index 100%
rename from rust/candid/tests/assets/ok/recursive_class.d.ts
rename to rust/candid_parser/tests/assets/ok/recursive_class.d.ts
diff --git a/rust/candid/tests/assets/ok/recursive_class.did b/rust/candid_parser/tests/assets/ok/recursive_class.did
similarity index 100%
rename from rust/candid/tests/assets/ok/recursive_class.did
rename to rust/candid_parser/tests/assets/ok/recursive_class.did
diff --git a/rust/candid/tests/assets/ok/recursive_class.js b/rust/candid_parser/tests/assets/ok/recursive_class.js
similarity index 100%
rename from rust/candid/tests/assets/ok/recursive_class.js
rename to rust/candid_parser/tests/assets/ok/recursive_class.js
diff --git a/rust/candid/tests/assets/ok/recursive_class.mo b/rust/candid_parser/tests/assets/ok/recursive_class.mo
similarity index 100%
rename from rust/candid/tests/assets/ok/recursive_class.mo
rename to rust/candid_parser/tests/assets/ok/recursive_class.mo
diff --git a/rust/candid/tests/assets/ok/recursive_class.rs b/rust/candid_parser/tests/assets/ok/recursive_class.rs
similarity index 100%
rename from rust/candid/tests/assets/ok/recursive_class.rs
rename to rust/candid_parser/tests/assets/ok/recursive_class.rs
diff --git a/rust/candid/tests/assets/ok/service.d.ts b/rust/candid_parser/tests/assets/ok/service.d.ts
similarity index 100%
rename from rust/candid/tests/assets/ok/service.d.ts
rename to rust/candid_parser/tests/assets/ok/service.d.ts
diff --git a/rust/candid/tests/assets/ok/service.did b/rust/candid_parser/tests/assets/ok/service.did
similarity index 100%
rename from rust/candid/tests/assets/ok/service.did
rename to rust/candid_parser/tests/assets/ok/service.did
diff --git a/rust/candid/tests/assets/ok/service.js b/rust/candid_parser/tests/assets/ok/service.js
similarity index 100%
rename from rust/candid/tests/assets/ok/service.js
rename to rust/candid_parser/tests/assets/ok/service.js
diff --git a/rust/candid/tests/assets/ok/service.mo b/rust/candid_parser/tests/assets/ok/service.mo
similarity index 100%
rename from rust/candid/tests/assets/ok/service.mo
rename to rust/candid_parser/tests/assets/ok/service.mo
diff --git a/rust/candid/tests/assets/ok/service.rs b/rust/candid_parser/tests/assets/ok/service.rs
similarity index 100%
rename from rust/candid/tests/assets/ok/service.rs
rename to rust/candid_parser/tests/assets/ok/service.rs
diff --git a/rust/candid/tests/assets/ok/surrogate.fail b/rust/candid_parser/tests/assets/ok/surrogate.fail
similarity index 100%
rename from rust/candid/tests/assets/ok/surrogate.fail
rename to rust/candid_parser/tests/assets/ok/surrogate.fail
diff --git a/rust/candid/tests/assets/ok/undefine.fail b/rust/candid_parser/tests/assets/ok/undefine.fail
similarity index 100%
rename from rust/candid/tests/assets/ok/undefine.fail
rename to rust/candid_parser/tests/assets/ok/undefine.fail
diff --git a/rust/candid/tests/assets/ok/unicode.d.ts b/rust/candid_parser/tests/assets/ok/unicode.d.ts
similarity index 100%
rename from rust/candid/tests/assets/ok/unicode.d.ts
rename to rust/candid_parser/tests/assets/ok/unicode.d.ts
diff --git a/rust/candid/tests/assets/ok/unicode.did b/rust/candid_parser/tests/assets/ok/unicode.did
similarity index 100%
rename from rust/candid/tests/assets/ok/unicode.did
rename to rust/candid_parser/tests/assets/ok/unicode.did
diff --git a/rust/candid/tests/assets/ok/unicode.js b/rust/candid_parser/tests/assets/ok/unicode.js
similarity index 100%
rename from rust/candid/tests/assets/ok/unicode.js
rename to rust/candid_parser/tests/assets/ok/unicode.js
diff --git a/rust/candid/tests/assets/ok/unicode.rs b/rust/candid_parser/tests/assets/ok/unicode.rs
similarity index 100%
rename from rust/candid/tests/assets/ok/unicode.rs
rename to rust/candid_parser/tests/assets/ok/unicode.rs
diff --git a/rust/candid/tests/assets/oneway.did b/rust/candid_parser/tests/assets/oneway.did
similarity index 100%
rename from rust/candid/tests/assets/oneway.did
rename to rust/candid_parser/tests/assets/oneway.did
diff --git a/rust/candid/tests/assets/recursion.did b/rust/candid_parser/tests/assets/recursion.did
similarity index 100%
rename from rust/candid/tests/assets/recursion.did
rename to rust/candid_parser/tests/assets/recursion.did
diff --git a/rust/candid/tests/assets/recursive_class.did b/rust/candid_parser/tests/assets/recursive_class.did
similarity index 100%
rename from rust/candid/tests/assets/recursive_class.did
rename to rust/candid_parser/tests/assets/recursive_class.did
diff --git a/rust/candid/tests/assets/service.did b/rust/candid_parser/tests/assets/service.did
similarity index 100%
rename from rust/candid/tests/assets/service.did
rename to rust/candid_parser/tests/assets/service.did
diff --git a/rust/candid/tests/assets/surrogate.did b/rust/candid_parser/tests/assets/surrogate.did
similarity index 100%
rename from rust/candid/tests/assets/surrogate.did
rename to rust/candid_parser/tests/assets/surrogate.did
diff --git a/rust/candid/tests/assets/undefine.did b/rust/candid_parser/tests/assets/undefine.did
similarity index 100%
rename from rust/candid/tests/assets/undefine.did
rename to rust/candid_parser/tests/assets/undefine.did
diff --git a/rust/candid/tests/assets/unicode.did b/rust/candid_parser/tests/assets/unicode.did
similarity index 100%
rename from rust/candid/tests/assets/unicode.did
rename to rust/candid_parser/tests/assets/unicode.did
diff --git a/rust/candid/tests/parse_type.rs b/rust/candid_parser/tests/parse_type.rs
similarity index 88%
rename from rust/candid/tests/parse_type.rs
rename to rust/candid_parser/tests/parse_type.rs
index 85ec1362..7dfb2fb6 100644
--- a/rust/candid/tests/parse_type.rs
+++ b/rust/candid_parser/tests/parse_type.rs
@@ -1,7 +1,8 @@
-use candid::bindings::{candid as candid_export, javascript, motoko, rust, typescript};
-use candid::parser::types::IDLProg;
-use candid::parser::typing::{check_file, check_prog};
+use candid::pretty::candid::compile;
 use candid::types::TypeEnv;
+use candid_parser::bindings::{javascript, motoko, rust, typescript};
+use candid_parser::types::IDLProg;
+use candid_parser::typing::{check_file, check_prog};
 use goldenfile::Mint;
 use std::io::Write;
 use std::path::Path;
@@ -29,7 +30,7 @@ service server : {
     prog.parse::<IDLProg>().unwrap();
 }
 
-#[test_generator::test_resources("rust/candid/tests/assets/*.did")]
+#[test_generator::test_resources("rust/candid_parser/tests/assets/*.did")]
 fn compiler_test(resource: &str) {
     let base_path = std::env::current_dir().unwrap().join("tests/assets");
     let mut mint = Mint::new(base_path.join("ok"));
@@ -41,7 +42,7 @@ fn compiler_test(resource: &str) {
         Ok((env, actor)) => {
             {
                 let mut output = mint.new_goldenfile(filename.with_extension("did")).unwrap();
-                let content = candid_export::compile(&env, &actor);
+                let content = compile(&env, &actor);
                 // Type check output
                 let ast = content.parse::<IDLProg>().unwrap();
                 check_prog(&mut TypeEnv::new(), &ast).unwrap();
@@ -62,9 +63,9 @@ fn compiler_test(resource: &str) {
             }
             {
                 let mut config = rust::Config::new();
-                config.canister_id = Some(candid::Principal::from_text("aaaaa-aa").unwrap());
+                config.set_canister_id(candid::Principal::from_text("aaaaa-aa").unwrap());
                 if filename.file_name().unwrap().to_str().unwrap() == "management.did" {
-                    config.target = rust::Target::Agent;
+                    config.set_target(rust::Target::Agent);
                 }
                 let mut output = mint.new_goldenfile(filename.with_extension("rs")).unwrap();
                 let content = rust::compile(&config, &env, &actor);
diff --git a/rust/candid/tests/parse_value.rs b/rust/candid_parser/tests/parse_value.rs
similarity index 93%
rename from rust/candid/tests/parse_value.rs
rename to rust/candid_parser/tests/parse_value.rs
index 027401db..589c80d5 100644
--- a/rust/candid/tests/parse_value.rs
+++ b/rust/candid_parser/tests/parse_value.rs
@@ -1,20 +1,21 @@
 use candid::types::value::{IDLArgs, IDLField, IDLValue, VariantValue};
 use candid::types::{Label, Type, TypeEnv, TypeInner};
 use candid::{record, variant, CandidType, Nat};
+use candid_parser::parse_idl_args;
 
 fn parse_args(input: &str) -> IDLArgs {
-    input.parse().unwrap()
+    parse_idl_args(input).unwrap()
 }
 
-fn parse_args_err(input: &str) -> candid::Result<IDLArgs> {
-    input.parse()
+fn parse_args_err(input: &str) -> candid_parser::Result<IDLArgs> {
+    parse_idl_args(input)
 }
 
 fn parse_type(input: &str) -> Type {
-    use candid::parser::types::IDLType;
+    use candid_parser::types::IDLType;
     let env = TypeEnv::new();
     let ast = input.parse::<IDLType>().unwrap();
-    env.ast_to_type(&ast).unwrap()
+    candid_parser::typing::ast_to_type(&env, &ast).unwrap()
 }
 
 #[test]
@@ -93,7 +94,7 @@ fn parse_more_literals() {
         vec![
             IDLValue::Bool(true),
             IDLValue::Null,
-            IDLValue::Nat(42.into()),
+            IDLValue::Nat(42u8.into()),
             IDLValue::Text("哈哈".to_owned()),
             IDLValue::Text("string with whitespace".to_owned()),
             IDLValue::Int(42.into()),
@@ -120,10 +121,10 @@ fn parse_vec() {
     assert_eq!(
         args.args,
         vec![IDLValue::Vec(vec![
-            IDLValue::Nat(1.into()),
-            IDLValue::Nat(2.into()),
-            IDLValue::Nat(3.into()),
-            IDLValue::Nat(4.into())
+            IDLValue::Nat(1u8.into()),
+            IDLValue::Nat(2u8.into()),
+            IDLValue::Nat(3u8.into()),
+            IDLValue::Nat(4u8.into())
         ])]
     );
     assert_eq!(
@@ -153,7 +154,7 @@ fn parse_optional_record() {
             IDLValue::Record(vec![
                 IDLField {
                     id: Label::Id(1),
-                    val: IDLValue::Nat(42.into())
+                    val: IDLValue::Nat(42u8.into())
                 },
                 IDLField {
                     id: Label::Id(2),
@@ -216,7 +217,7 @@ fn parse_nested_record() {
             },
             IDLField {
                 id: Label::Named("label".to_owned()),
-                val: IDLValue::Nat(42.into())
+                val: IDLValue::Nat(42u8.into())
             }
         ])]
     );
@@ -251,7 +252,7 @@ fn parse_annval() {
         args,
         IDLArgs {
             args: vec![
-                IDLValue::Nat(1.into()),
+                IDLValue::Nat(1u8.into()),
                 IDLValue::Int(123.into()),
                 IDLValue::Int32(456),
                 IDLValue::Float32(789f32),
diff --git a/rust/candid/tests/test_suite.rs b/rust/candid_parser/tests/test_suite.rs
similarity index 85%
rename from rust/candid/tests/test_suite.rs
rename to rust/candid_parser/tests/test_suite.rs
index e3a68fa1..83a07133 100644
--- a/rust/candid/tests/test_suite.rs
+++ b/rust/candid_parser/tests/test_suite.rs
@@ -1,4 +1,4 @@
-use candid::parser::test::{check, Test};
+use candid_parser::test::{check, Test};
 
 #[test_generator::test_resources("test/*.test.did")]
 fn decode_test(resource: &str) {
@@ -13,7 +13,7 @@ fn decode_test(resource: &str) {
 
 #[test_generator::test_resources("test/*.test.did")]
 fn js_test(resource: &str) {
-    use candid::bindings::javascript::test::test_generate;
+    use candid_parser::bindings::javascript::test::test_generate;
     let path = std::env::current_dir()
         .unwrap()
         .join("../../")
diff --git a/rust/candid/tests/value.rs b/rust/candid_parser/tests/value.rs
similarity index 93%
rename from rust/candid/tests/value.rs
rename to rust/candid_parser/tests/value.rs
index fd3f4f61..56ec90e3 100644
--- a/rust/candid/tests/value.rs
+++ b/rust/candid_parser/tests/value.rs
@@ -1,7 +1,7 @@
-use candid::parser::{types::IDLProg, typing::check_prog};
 use candid::types::value::{IDLArgs, IDLField, IDLValue, VariantValue};
 use candid::types::{Label, TypeEnv};
 use candid::{decode_args, decode_one, Decode};
+use candid_parser::{parse_idl_args, types::IDLProg, typing::check_prog};
 
 #[test]
 fn test_parser() {
@@ -36,7 +36,7 @@ service : {
     let actor = check_prog(&mut env, &ast).unwrap().unwrap();
     let method = env.get_method(&actor, "f").unwrap();
     {
-        let args = "(42,42,42,42)".parse::<IDLArgs>().unwrap();
+        let args = parse_idl_args("(42,42,42,42)").unwrap();
         let encoded = args.to_bytes_with_types(&env, &method.args).unwrap();
         let decoded = IDLArgs::from_bytes(&encoded).unwrap();
         assert_eq!(
@@ -44,14 +44,14 @@ service : {
             vec![
                 IDLValue::Nat8(42),
                 IDLValue::Int(42.into()),
-                IDLValue::Nat(42.into()),
+                IDLValue::Nat(42u32.into()),
                 IDLValue::Int8(42),
             ]
         );
     }
     {
         let str = "(opt record { head = 1000; tail = opt record {head = -2000; tail = null}}, variant {a = 42})";
-        let args = str.parse::<IDLArgs>().unwrap();
+        let args = parse_idl_args(str).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 : int16;\n    1_291_237_008 = opt record {\n      1_158_359_328 = -2_000 : int16;\n      1_291_237_008 = null;\n    };\n  },\n  variant { 97 = 42 : nat },\n)");
@@ -73,6 +73,7 @@ fn test_value() {
     check(Opt(Box::new(Int(42.into()))), "4449444c016e7c0100012a");
     check(Text("Hi ☃\n".to_string()), "4449444c00017107486920e298830a");
     check(Reserved, "4449444c000170");
+    check(Blob(vec![1, 2, 3, 4]), "4449444c016d7b01000401020304");
     test_decode(&hex("4449444c016e7c010000"), &None);
     check(int_vec(&[0, 1, 2, 3]), "4449444c016d7c01000400010203");
     check(
@@ -120,11 +121,11 @@ fn test_variant() {
 }
 
 fn parse_check(str: &str) {
-    let args = str.parse::<IDLArgs>().unwrap();
+    let args = parse_idl_args(str).unwrap();
     let encoded = args.to_bytes().unwrap();
     let decoded = IDLArgs::from_bytes(&encoded).unwrap();
     let output = decoded.to_string();
-    let back_args = output.parse::<IDLArgs>().unwrap();
+    let back_args = parse_idl_args(&output).unwrap();
     let annotated_args = args
         .annotate_types(true, &TypeEnv::new(), &back_args.get_types())
         .unwrap();
diff --git a/rust/ic_principal/Cargo.toml b/rust/ic_principal/Cargo.toml
new file mode 100644
index 00000000..cc0801bc
--- /dev/null
+++ b/rust/ic_principal/Cargo.toml
@@ -0,0 +1,44 @@
+[package]
+name = "ic_principal"
+version = "0.1.0"
+authors = ["DFINITY Stiftung <sdk@dfinity.org>"]
+edition = "2021"
+homepage = "https://internetcomputer.org/docs/current/references/id-encoding-spec"
+documentation = "https://docs.rs/ic_principal"
+repository="https://github.com/dfinity/candid"
+license = "Apache-2.0"
+readme = "README.md"
+categories = ["data-structures", "no-std"]
+keywords = ["internet-computer", "types", "dfinity"]
+include = ["src", "Cargo.toml", "LICENSE", "README.md"]
+
+[dependencies]
+crc32fast = "1.3.0"
+data-encoding = "2.3.2"
+hex = "0.4.3"
+sha2 = "0.10.1"
+thiserror = "1.0.30"
+
+[dev-dependencies]
+serde_cbor = "0.11.2"
+serde_json = "1.0.74"
+serde_test = "1.0.137"
+impls = "1"
+
+[dependencies.serde]
+version = "1.0.115"
+features = ["derive"]
+optional = true
+
+[dependencies.serde_bytes]
+version = "0.11.5"
+optional = true
+
+[dependencies.arbitrary]
+workspace = true
+optional = true
+
+[features]
+# Default features include serde support.
+default = ['serde', 'serde_bytes']
+arbitrary = ['default', 'dep:arbitrary']
diff --git a/rust/ic_principal/LICENSE b/rust/ic_principal/LICENSE
new file mode 120000
index 00000000..30cff740
--- /dev/null
+++ b/rust/ic_principal/LICENSE
@@ -0,0 +1 @@
+../../LICENSE
\ No newline at end of file
diff --git a/rust/ic_principal/README.md b/rust/ic_principal/README.md
new file mode 100644
index 00000000..b32805eb
--- /dev/null
+++ b/rust/ic_principal/README.md
@@ -0,0 +1,5 @@
+# Internet Computer Principal
+
+`Principal` is the data structure for generic identifiers on the Internet Computer.
+
+Check the [ID encoding specification](https://internetcomputer.org/docs/current/references/id-encoding-spec) for more information.
diff --git a/rust/ic_principal/src/lib.rs b/rust/ic_principal/src/lib.rs
new file mode 100644
index 00000000..237560a5
--- /dev/null
+++ b/rust/ic_principal/src/lib.rs
@@ -0,0 +1,388 @@
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha224};
+use std::convert::TryFrom;
+use std::fmt::Write;
+use thiserror::Error;
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Result as ArbitraryResult, Unstructured};
+
+/// An error happened while encoding, decoding or serializing a [`Principal`].
+#[derive(Error, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum PrincipalError {
+    #[error("Bytes is longer than 29 bytes.")]
+    BytesTooLong(),
+
+    #[error("Text must be in valid Base32 encoding.")]
+    InvalidBase32(),
+
+    #[error("Text is too short.")]
+    TextTooShort(),
+
+    #[error("Text is too long.")]
+    TextTooLong(),
+
+    #[error("CRC32 check sequence doesn't match with calculated from Principal bytes.")]
+    CheckSequenceNotMatch(),
+
+    #[error(r#"Text should be separated by - (dash) every 5 characters: expected "{0}""#)]
+    AbnormalGrouped(Principal),
+}
+
+/// Generic ID on Internet Computer.
+///
+/// Principals are generic identifiers for canisters, users
+/// and possibly other concepts in the future.
+/// As far as most uses of the IC are concerned they are
+/// opaque binary blobs with a length between 0 and 29 bytes,
+/// and there is intentionally no mechanism to tell canister ids and user ids apart.
+///
+/// Note a principal is not necessarily tied with a public key-pair,
+/// yet we need at least a key-pair of a related principal to sign
+/// requests.
+///
+/// A Principal can be serialized to a byte array ([`Vec<u8>`]) or a text
+/// representation, but the inner structure of the byte representation
+/// is kept private.
+///
+/// Example of using a Principal object:
+/// ```
+/// use ic_principal::Principal;
+///
+/// let text = "aaaaa-aa";  // The management canister ID.
+/// let principal = Principal::from_text(text).expect("Could not decode the principal.");
+/// assert_eq!(principal.as_slice(), &[]);
+/// assert_eq!(principal.to_text(), text);
+/// ```
+///
+/// Serialization is enabled with the "serde" feature. It supports serializing
+/// to a byte bufer for non-human readable serializer, and a string version for human
+/// readable serializers.
+///
+/// ```
+/// use ic_principal::Principal;
+/// use serde::{Deserialize, Serialize};
+/// use std::str::FromStr;
+///
+/// #[derive(Serialize)]
+/// struct Data {
+///     id: Principal,
+/// }
+///
+/// let id = Principal::from_str("2chl6-4hpzw-vqaaa-aaaaa-c").unwrap();
+///
+/// // JSON is human readable, so this will serialize to a textual
+/// // representation of the Principal.
+/// assert_eq!(
+///     serde_json::to_string(&Data { id: id.clone() }).unwrap(),
+///     r#"{"id":"2chl6-4hpzw-vqaaa-aaaaa-c"}"#
+/// );
+///
+/// // CBOR is not human readable, so will serialize to bytes.
+/// assert_eq!(
+///     serde_cbor::to_vec(&Data { id: id.clone() }).unwrap(),
+///     &[161, 98, 105, 100, 73, 239, 205, 171, 0, 0, 0, 0, 0, 1],
+/// );
+/// ```
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Principal {
+    /// Length.
+    len: u8,
+
+    /// The content buffer. When returning slices this should always be sized according to
+    /// `len`.
+    bytes: [u8; Self::MAX_LENGTH_IN_BYTES],
+}
+
+impl Principal {
+    const MAX_LENGTH_IN_BYTES: usize = 29;
+    const CRC_LENGTH_IN_BYTES: usize = 4;
+
+    const SELF_AUTHENTICATING_TAG: u8 = 2;
+    const ANONYMOUS_TAG: u8 = 4;
+
+    /// Construct a [`Principal`] of the IC management canister
+    pub const fn management_canister() -> Self {
+        Self {
+            len: 0,
+            bytes: [0; Self::MAX_LENGTH_IN_BYTES],
+        }
+    }
+
+    /// Construct a self-authenticating ID from public key
+    pub fn self_authenticating<P: AsRef<[u8]>>(public_key: P) -> Self {
+        let public_key = public_key.as_ref();
+        let hash = Sha224::digest(public_key);
+        let mut bytes = [0; Self::MAX_LENGTH_IN_BYTES];
+        bytes[..Self::MAX_LENGTH_IN_BYTES - 1].copy_from_slice(hash.as_slice());
+        bytes[Self::MAX_LENGTH_IN_BYTES - 1] = Self::SELF_AUTHENTICATING_TAG;
+
+        Self {
+            len: Self::MAX_LENGTH_IN_BYTES as u8,
+            bytes,
+        }
+    }
+
+    /// Construct an anonymous ID.
+    pub const fn anonymous() -> Self {
+        let mut bytes = [0; Self::MAX_LENGTH_IN_BYTES];
+        bytes[0] = Self::ANONYMOUS_TAG;
+        Self { len: 1, bytes }
+    }
+
+    /// Construct a [`Principal`] from a slice of bytes.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the slice is longer than 29 bytes.
+    pub const fn from_slice(slice: &[u8]) -> Self {
+        match Self::try_from_slice(slice) {
+            Ok(v) => v,
+            _ => panic!("slice length exceeds capacity"),
+        }
+    }
+
+    /// Construct a [`Principal`] from a slice of bytes.
+    pub const fn try_from_slice(slice: &[u8]) -> Result<Self, PrincipalError> {
+        const MAX_LENGTH_IN_BYTES: usize = Principal::MAX_LENGTH_IN_BYTES;
+        match slice.len() {
+            len @ 0..=MAX_LENGTH_IN_BYTES => {
+                let mut bytes = [0; MAX_LENGTH_IN_BYTES];
+                let mut i = 0;
+                while i < len {
+                    bytes[i] = slice[i];
+                    i += 1;
+                }
+                Ok(Self {
+                    len: len as u8,
+                    bytes,
+                })
+            }
+            _ => Err(PrincipalError::BytesTooLong()),
+        }
+    }
+
+    /// Parse a [`Principal`] from text representation.
+    pub fn from_text<S: AsRef<str>>(text: S) -> Result<Self, PrincipalError> {
+        // Strategy: Parse very liberally, then pretty-print and compare output
+        // This is both simpler and yields better error messages
+
+        let mut s = text.as_ref().to_string();
+        s.make_ascii_uppercase();
+        s.retain(|c| c != '-');
+        match data_encoding::BASE32_NOPAD.decode(s.as_bytes()) {
+            Ok(bytes) => {
+                if bytes.len() < Self::CRC_LENGTH_IN_BYTES {
+                    return Err(PrincipalError::TextTooShort());
+                }
+
+                let crc_bytes = &bytes[..Self::CRC_LENGTH_IN_BYTES];
+                let data_bytes = &bytes[Self::CRC_LENGTH_IN_BYTES..];
+                if data_bytes.len() > Self::MAX_LENGTH_IN_BYTES {
+                    return Err(PrincipalError::TextTooLong());
+                }
+
+                if crc32fast::hash(data_bytes).to_be_bytes() != crc_bytes {
+                    return Err(PrincipalError::CheckSequenceNotMatch());
+                }
+
+                // Already checked data_bytes.len() <= MAX_LENGTH_IN_BYTES
+                // safe to unwrap here
+                let result = Self::try_from_slice(data_bytes).unwrap();
+                let expected = format!("{result}");
+
+                // In the Spec:
+                // The textual representation is conventionally printed with lower case letters,
+                // but parsed case-insensitively.
+                if text.as_ref().to_ascii_lowercase() != expected {
+                    return Err(PrincipalError::AbnormalGrouped(result));
+                }
+                Ok(result)
+            }
+            _ => Err(PrincipalError::InvalidBase32()),
+        }
+    }
+
+    /// Convert [`Principal`] to text representation.
+    pub fn to_text(&self) -> String {
+        format!("{self}")
+    }
+
+    /// Return the [`Principal`]'s underlying slice of bytes.
+    #[inline]
+    pub fn as_slice(&self) -> &[u8] {
+        &self.bytes[..self.len as usize]
+    }
+}
+
+impl std::fmt::Display for Principal {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let blob: &[u8] = self.as_slice();
+
+        // calc checksum
+        let checksum = crc32fast::hash(blob);
+
+        // combine blobs
+        let mut bytes = vec![];
+        bytes.extend_from_slice(&checksum.to_be_bytes());
+        bytes.extend_from_slice(blob);
+
+        // base32
+        let mut s = data_encoding::BASE32_NOPAD.encode(&bytes);
+        s.make_ascii_lowercase();
+
+        // write out string with dashes
+        let mut s = s.as_str();
+        while s.len() > 5 {
+            f.write_str(&s[..5])?;
+            f.write_char('-')?;
+            s = &s[5..];
+        }
+        f.write_str(s)
+    }
+}
+
+impl std::str::FromStr for Principal {
+    type Err = PrincipalError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Principal::from_text(s)
+    }
+}
+
+impl TryFrom<&str> for Principal {
+    type Error = PrincipalError;
+
+    fn try_from(s: &str) -> Result<Self, Self::Error> {
+        Principal::from_text(s)
+    }
+}
+
+impl TryFrom<Vec<u8>> for Principal {
+    type Error = PrincipalError;
+
+    fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
+        Self::try_from(bytes.as_slice())
+    }
+}
+
+impl TryFrom<&Vec<u8>> for Principal {
+    type Error = PrincipalError;
+
+    fn try_from(bytes: &Vec<u8>) -> Result<Self, Self::Error> {
+        Self::try_from(bytes.as_slice())
+    }
+}
+
+impl TryFrom<&[u8]> for Principal {
+    type Error = PrincipalError;
+
+    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
+        Self::try_from_slice(bytes)
+    }
+}
+
+impl AsRef<[u8]> for Principal {
+    fn as_ref(&self) -> &[u8] {
+        self.as_slice()
+    }
+}
+
+// Serialization
+#[cfg(feature = "serde")]
+impl serde::Serialize for Principal {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        if serializer.is_human_readable() {
+            self.to_text().serialize(serializer)
+        } else {
+            serializer.serialize_bytes(self.as_slice())
+        }
+    }
+}
+
+// Deserialization
+#[cfg(feature = "serde")]
+mod deserialize {
+    use super::Principal;
+    use std::convert::TryFrom;
+
+    // Simple visitor for deserialization from bytes. We don't support other number types
+    // as there's no need for it.
+    pub(super) struct PrincipalVisitor;
+
+    impl<'de> serde::de::Visitor<'de> for PrincipalVisitor {
+        type Value = super::Principal;
+
+        fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            formatter.write_str("bytes or string")
+        }
+
+        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            Principal::from_text(v).map_err(E::custom)
+        }
+
+        fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            Principal::try_from(value).map_err(E::custom)
+        }
+        /// This visitor should only be used by the Candid crate.
+        fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            if v.is_empty() || v[0] != 2u8 {
+                Err(E::custom("Not called by Candid"))
+            } else {
+                Principal::try_from(&v[1..]).map_err(E::custom)
+            }
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Principal {
+    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Principal, D::Error> {
+        use serde::de::Error;
+        if deserializer.is_human_readable() {
+            deserializer
+                .deserialize_str(deserialize::PrincipalVisitor)
+                .map_err(D::Error::custom)
+        } else {
+            deserializer
+                .deserialize_bytes(deserialize::PrincipalVisitor)
+                .map_err(D::Error::custom)
+        }
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for Principal {
+    fn arbitrary(u: &mut Unstructured<'a>) -> ArbitraryResult<Self> {
+        let principal = match u8::arbitrary(u)? {
+            u8::MAX => Principal::management_canister(),
+            254u8 => Principal::anonymous(),
+            _ => {
+                let length: usize = u.int_in_range(1..=Principal::MAX_LENGTH_IN_BYTES)?;
+                let mut result: Vec<u8> = Vec::with_capacity(length);
+                for _ in 0..length {
+                    result.push(u8::arbitrary(u)?);
+                }
+                // non-anonymous principal cannot have type ANONYMOUS
+                // adapt by changing the last byte.
+                let last = result.last_mut().unwrap();
+                if *last == 4_u8 {
+                    *last = u8::MAX;
+                }
+                Principal::try_from(&result[..]).unwrap()
+            }
+        };
+        Ok(principal)
+    }
+}
diff --git a/rust/candid/tests/principal.rs b/rust/ic_principal/tests/principal.rs
similarity index 98%
rename from rust/candid/tests/principal.rs
rename to rust/ic_principal/tests/principal.rs
index ec402be6..25393889 100644
--- a/rust/candid/tests/principal.rs
+++ b/rust/ic_principal/tests/principal.rs
@@ -1,6 +1,7 @@
-#![allow(deprecated)]
+// #![allow(deprecated)]
 
-use candid::types::principal::{Principal, PrincipalError};
+use ic_principal::Principal;
+use ic_principal::PrincipalError;
 
 const MANAGEMENT_CANISTER_BYTES: [u8; 0] = [];
 const MANAGEMENT_CANISTER_TEXT: &str = "aaaaa-aa";
diff --git a/tools/didc/Cargo.toml b/tools/didc/Cargo.toml
index f1cf5e91..bf9af2a3 100644
--- a/tools/didc/Cargo.toml
+++ b/tools/didc/Cargo.toml
@@ -5,7 +5,7 @@ authors = ["DFINITY Team"]
 edition = "2021"
 
 [dependencies]
-candid = { path = "../../rust/candid", features = ["all"] }
+candid_parser = { path = "../../rust/candid_parser", features = ["all"] }
 clap = { version = "4.3", features = ["derive"] }
 pretty-hex = "0.2.1"
 hex = "0.4.2"
diff --git a/tools/didc/src/main.rs b/tools/didc/src/main.rs
index 9a349fab..b3f8d385 100644
--- a/tools/didc/src/main.rs
+++ b/tools/didc/src/main.rs
@@ -1,9 +1,11 @@
 use anyhow::{bail, Result};
-use candid::{
-    parser::types::{IDLType, IDLTypes},
-    pretty_check_file, pretty_parse,
-    types::Type,
-    Error, IDLArgs, TypeEnv,
+use candid_parser::candid::types::{subtype, Type};
+use candid_parser::{
+    error::pretty_diagnose,
+    parse_idl_args, parse_idl_value, pretty_check_file, pretty_parse,
+    types::{IDLType, IDLTypes},
+    typing::ast_to_type,
+    Error, IDLArgs, IDLValue, TypeEnv,
 };
 use clap::Parser;
 use std::collections::HashSet;
@@ -78,6 +80,7 @@ enum Command {
         /// Specifies target language
         lang: String,
         #[clap(short, long, requires("method"))]
+        #[clap(value_parser = parse_args)]
         /// Specifies input arguments for a method call, mocking the return result
         args: Option<IDLArgs>,
     },
@@ -113,7 +116,7 @@ impl TypeAnnotation {
     fn is_empty(&self) -> bool {
         self.tys.is_none() && self.method.is_none()
     }
-    fn get_types(&self, mode: Mode) -> candid::Result<(TypeEnv, Vec<Type>)> {
+    fn get_types(&self, mode: Mode) -> candid_parser::Result<(TypeEnv, Vec<Type>)> {
         let (env, actor) = if let Some(ref file) = self.defs {
             pretty_check_file(file)?
         } else {
@@ -124,7 +127,7 @@ impl TypeAnnotation {
             (Some(tys), None) => {
                 let mut types = Vec::new();
                 for ty in tys.args.iter() {
-                    types.push(env.ast_to_type(ty)?);
+                    types.push(ast_to_type(&env, ty)?);
                 }
                 Ok((env, types))
             }
@@ -145,7 +148,10 @@ impl TypeAnnotation {
 }
 
 fn parse_args(str: &str) -> Result<IDLArgs, Error> {
-    pretty_parse("candid arguments", str)
+    parse_idl_args(str).map_err(|e| {
+        let _ = pretty_diagnose("candid arguments", str, &e);
+        e
+    })
 }
 fn parse_types(str: &str) -> Result<IDLTypes, Error> {
     pretty_parse("type annotations", str)
@@ -166,9 +172,9 @@ fn main() -> Result<()> {
                         let mut gamma = HashSet::new();
                         let t2 = env.merge_type(env2, t2);
                         if strict {
-                            candid::types::subtype::equal(&mut gamma, &env, &t1, &t2)?;
+                            subtype::equal(&mut gamma, &env, &t1, &t2)?;
                         } else {
-                            candid::types::subtype::subtype(&mut gamma, &env, &t1, &t2)?;
+                            subtype::subtype(&mut gamma, &env, &t1, &t2)?;
                         }
                     }
                     _ => {
@@ -183,25 +189,25 @@ fn main() -> Result<()> {
             } else {
                 (TypeEnv::new(), None)
             };
-            let ty1 = env.ast_to_type(&ty1)?;
-            let ty2 = env.ast_to_type(&ty2)?;
-            candid::types::subtype::subtype(&mut HashSet::new(), &env, &ty1, &ty2)?;
+            let ty1 = ast_to_type(&env, &ty1)?;
+            let ty2 = ast_to_type(&env, &ty2)?;
+            subtype::subtype(&mut HashSet::new(), &env, &ty1, &ty2)?;
         }
         Command::Bind { input, target } => {
             let (env, actor) = pretty_check_file(&input)?;
             let content = match target.as_str() {
-                "js" => candid::bindings::javascript::compile(&env, &actor),
-                "ts" => candid::bindings::typescript::compile(&env, &actor),
-                "did" => candid::bindings::candid::compile(&env, &actor),
-                "mo" => candid::bindings::motoko::compile(&env, &actor),
+                "js" => candid_parser::bindings::javascript::compile(&env, &actor),
+                "ts" => candid_parser::bindings::typescript::compile(&env, &actor),
+                "did" => candid_parser::pretty::candid::compile(&env, &actor),
+                "mo" => candid_parser::bindings::motoko::compile(&env, &actor),
                 "rs" => {
-                    let config = candid::bindings::rust::Config::new();
-                    candid::bindings::rust::compile(&config, &env, &actor)
+                    let config = candid_parser::bindings::rust::Config::new();
+                    candid_parser::bindings::rust::compile(&config, &env, &actor)
                 }
                 "rs-agent" => {
-                    let mut config = candid::bindings::rust::Config::new();
-                    config.target = candid::bindings::rust::Target::Agent;
-                    candid::bindings::rust::compile(&config, &env, &actor)
+                    let mut config = candid_parser::bindings::rust::Config::new();
+                    config.set_target(candid_parser::bindings::rust::Target::Agent);
+                    candid_parser::bindings::rust::compile(&config, &env, &actor)
                 }
                 _ => unreachable!(),
             };
@@ -210,11 +216,11 @@ fn main() -> Result<()> {
         Command::Test { input, target } => {
             let test = std::fs::read_to_string(&input)
                 .map_err(|_| Error::msg(format!("could not read file {}", input.display())))?;
-            let ast = pretty_parse::<candid::parser::test::Test>(input.to_str().unwrap(), &test)?;
+            let ast = pretty_parse::<candid_parser::test::Test>(input.to_str().unwrap(), &test)?;
             let content = match target.as_str() {
-                "js" => candid::bindings::javascript::test::test_generate(ast),
+                "js" => candid_parser::bindings::javascript::test::test_generate(ast),
                 "did" => {
-                    candid::parser::test::check(ast)?;
+                    candid_parser::test::check(ast)?;
                     "".to_string()
                 }
                 _ => unreachable!(),
@@ -222,7 +228,7 @@ fn main() -> Result<()> {
             println!("{content}");
         }
         Command::Hash { input } => {
-            println!("{}", candid::idl_hash(&input));
+            println!("{}", candid_parser::idl_hash(&input));
         }
         Command::Encode {
             args,
@@ -248,7 +254,7 @@ fn main() -> Result<()> {
                 "blob" => {
                     let mut res = String::new();
                     for ch in bytes.iter() {
-                        res.push_str(&candid::bindings::candid::value::pp_char(*ch));
+                        res.push_str(&candid_parser::pretty::candid::value::pp_char(*ch));
                     }
                     format!("blob \"{res}\"")
                 }
@@ -272,8 +278,10 @@ fn main() -> Result<()> {
                         .collect::<String>(),
                 )?,
                 "blob" => {
-                    use candid::types::value::IDLValue;
-                    match pretty_parse::<IDLValue>("blob", &blob)? {
+                    match parse_idl_value(&blob).map_err(|e| {
+                        let _ = pretty_diagnose("blob", &blob, &e);
+                        e
+                    })? {
                         IDLValue::Vec(vec) => vec
                             .iter()
                             .map(|v| {
@@ -304,7 +312,7 @@ fn main() -> Result<()> {
             file,
             args,
         } => {
-            use candid::parser::configs::Configs;
+            use candid_parser::configs::Configs;
             use rand::Rng;
             let (env, types) = if args.is_some() {
                 annotate.get_types(Mode::Decode)?
@@ -335,12 +343,12 @@ fn main() -> Result<()> {
                 let mut rng = rand::thread_rng();
                 (0..2048).map(|_| rng.gen::<u8>()).collect()
             };
-            let args = IDLArgs::any(&seed, &config, &env, &types)?;
+            let args = candid_parser::random::any(&seed, &config, &env, &types)?;
             match lang.as_str() {
                 "did" => println!("{args}"),
                 "js" => println!(
                     "{}",
-                    candid::bindings::javascript::value::pp_args(&args).pretty(80)
+                    candid_parser::bindings::javascript::value::pp_args(&args).pretty(80)
                 ),
                 _ => unreachable!(),
             }