From b5316f98b022df2c9180b5c01d9511243f4ecf09 Mon Sep 17 00:00:00 2001
From: Yan Chen <48968912+chenyan-dfinity@users.noreply.github.com>
Date: Fri, 27 Oct 2023 16:37:12 -0700
Subject: [PATCH] Remove candid dependencies (#485)

* remove num_enum

* clean up parser dependencies

* checkpoint

* value feature

* remove codespan

* fix

* fix

* pretty

* remove mute_warning

* fix

* pretty refactor

* fix

* reexport candid in parser

* fix

* fix

* fix

* bignum feature

* bump candid_derive

* silence subtyping in decoder

* fix service_equal error reporting (#486)

* add IDLValue::Blob

* builder for config

* fix

* fix
---
 .github/workflows/bench.yml                   |   2 +-
 .github/workflows/rust.yml                    |   8 +-
 Cargo.lock                                    | 176 ++++++------------
 Cargo.toml                                    |   9 +
 Changelog.md                                  |  17 +-
 rust/candid/Cargo.toml                        |  55 ++++--
 rust/candid/src/de.rs                         | 101 +++++++---
 rust/candid/src/error.rs                      |  41 +++-
 rust/candid/src/lib.rs                        |  32 +++-
 .../{pretty_printer.rs => pretty/candid.rs}   |  31 ++-
 rust/candid/src/pretty/mod.rs                 |   4 +
 .../candid/src/{pretty.rs => pretty/utils.rs} |   0
 rust/candid/src/ser.rs                        |  13 ++
 rust/candid/src/types/arc.rs                  |   3 +-
 rust/candid/src/types/impls.rs                |   8 +-
 rust/candid/src/types/internal.rs             |  66 +++++--
 rust/candid/src/types/leb128.rs               | 100 ++++++++++
 rust/candid/src/types/mod.rs                  |  10 +
 rust/candid/src/types/number.rs               |  16 +-
 rust/candid/src/types/rc.rs                   |   3 +-
 rust/candid/src/types/subtype.rs              | 104 ++++++++---
 rust/candid/src/types/value.rs                |  19 +-
 rust/candid/src/utils.rs                      |  14 ++
 rust/candid/tests/number.rs                   |  13 ++
 rust/candid/tests/serde.rs                    |   2 +
 rust/candid_derive/Cargo.toml                 |   2 +-
 rust/candid_derive/src/func.rs                |   2 +-
 rust/candid_parser/Cargo.toml                 |  24 +--
 rust/candid_parser/src/bindings/javascript.rs |  15 +-
 rust/candid_parser/src/bindings/motoko.rs     |   4 +-
 rust/candid_parser/src/bindings/rust.rs       |  40 +++-
 rust/candid_parser/src/bindings/typescript.rs |   2 +-
 rust/candid_parser/src/grammar.lalrpop        |   5 +-
 rust/candid_parser/src/lib.rs                 |   5 +
 rust/candid_parser/tests/parse_type.rs        |   6 +-
 tools/didc/Cargo.toml                         |   1 -
 tools/didc/src/main.rs                        |  19 +-
 37 files changed, 666 insertions(+), 306 deletions(-)
 rename rust/candid/src/{pretty_printer.rs => pretty/candid.rs} (94%)
 create mode 100644 rust/candid/src/pretty/mod.rs
 rename rust/candid/src/{pretty.rs => pretty/utils.rs} (100%)
 create mode 100644 rust/candid/src/types/leb128.rs

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 8b07d2e9..9a9cfa8d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -138,7 +138,7 @@ version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
 dependencies = [
- "hermit-abi",
+ "hermit-abi 0.1.19",
  "libc",
  "winapi",
 ]
@@ -264,14 +264,12 @@ dependencies = [
  "binread",
  "byteorder",
  "candid_derive",
- "codespan-reporting",
  "criterion",
  "hex",
  "ic_principal",
  "leb128",
  "num-bigint",
  "num-traits",
- "num_enum",
  "paste",
  "pretty 0.12.3",
  "rand",
@@ -285,7 +283,7 @@ dependencies = [
 
 [[package]]
 name = "candid_derive"
-version = "0.6.4"
+version = "0.6.5"
 dependencies = [
  "lazy_static",
  "proc-macro2 1.0.69",
@@ -313,10 +311,7 @@ dependencies = [
  "pretty 0.12.3",
  "rand",
  "serde",
- "serde_bytes",
  "serde_dhall",
- "sha2 0.10.8",
- "stacker",
  "test-generator",
  "thiserror",
 ]
@@ -383,9 +378,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.4.6"
+version = "4.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d04704f56c2cde07f43e8e2c154b43f216dc5c92fc98ada720177362f953b956"
+checksum = "ac495e00dcec98c83465d5ad66c5c4fabd652fd6686e7c6269b117e729a6f17b"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -393,21 +388,21 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.4.6"
+version = "4.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e231faeaca65ebd1ea3c737966bf858971cd38c3849107aa3ea7de90a804e45"
+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.69",
@@ -426,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"
@@ -576,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"
@@ -617,14 +618,19 @@ name = "didc"
 version = "0.3.5"
 dependencies = [
  "anyhow",
- "candid",
  "candid_parser",
- "clap 4.4.6",
+ "clap 4.4.7",
  "hex",
  "pretty-hex",
  "rand",
 ]
 
+[[package]]
+name = "diff"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
+
 [[package]]
 name = "digest"
 version = "0.9.0"
@@ -719,12 +725,12 @@ dependencies = [
 
 [[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]]
@@ -824,6 +830,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "hermit-abi"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d77f7ec81a6d05a3abb01ab6eb7590f6083d08449fe5a1c8b1e620283546ccb7"
+
 [[package]]
 name = "hex"
 version = "0.4.3"
@@ -893,28 +905,30 @@ dependencies = [
 ]
 
 [[package]]
-name = "itertools"
-version = "0.9.0"
+name = "is-terminal"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "284f18f85651fe11e8a991b2adb42cb078325c996ed026d994719efcfca1d54b"
+checksum = "cb0889898416213fab133e1d33a0e5858a48177452750691bde3666d0fdbaf8b"
 dependencies = [
- "either",
+ "hermit-abi 0.3.3",
+ "rustix",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "itertools"
-version = "0.10.5"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+checksum = "284f18f85651fe11e8a991b2adb42cb078325c996ed026d994719efcfca1d54b"
 dependencies = [
  "either",
 ]
 
 [[package]]
 name = "itertools"
-version = "0.11.0"
+version = "0.10.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
 dependencies = [
  "either",
 ]
@@ -936,14 +950,16 @@ dependencies = [
 
 [[package]]
 name = "lalrpop"
-version = "0.20.1"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83be602e051ada38d90c7841092adabeb585197afe9dabb20e4f8375cc87846e"
+checksum = "da4081d44f4611b66c6dd725e6de3169f9f63905421e8626fcb86b6a898998b8"
 dependencies = [
  "ascii-canvas",
  "bit-set",
+ "diff",
  "ena",
- "itertools 0.11.0",
+ "is-terminal",
+ "itertools 0.10.5",
  "lalrpop-util",
  "petgraph",
  "pico-args",
@@ -957,11 +973,11 @@ dependencies = [
 
 [[package]]
 name = "lalrpop-util"
-version = "0.20.1"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "365d88f9d803538a06641e6736f21d95ecf9226dc1693421212e62c405cdd199"
+checksum = "3f35c735096c0293d313e8f2a641627472b83d01b937177fe76e5e2708d31e0d"
 dependencies = [
- "regex-automata 0.3.9",
+ "regex",
 ]
 
 [[package]]
@@ -1104,27 +1120,6 @@ 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.69",
- "quote 1.0.33",
- "syn 2.0.38",
-]
-
 [[package]]
 name = "once_cell"
 version = "1.18.0"
@@ -1186,9 +1181,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",
@@ -1219,9 +1214,9 @@ dependencies = [
 
 [[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",
@@ -1229,9 +1224,9 @@ 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",
@@ -1242,9 +1237,9 @@ dependencies = [
 
 [[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",
@@ -1345,16 +1340,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"
@@ -1506,17 +1491,6 @@ version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
 
-[[package]]
-name = "regex-automata"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59b23e92ee4318893fa3fe3e6fb365258efbfe6ac6ab30f090cdcbb7aa37efa9"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax 0.7.5",
-]
-
 [[package]]
 name = "regex-automata"
 version = "0.4.3"
@@ -1890,23 +1864,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
-[[package]]
-name = "toml_datetime"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
-
-[[package]]
-name = "toml_edit"
-version = "0.19.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
-dependencies = [
- "indexmap 2.0.2",
- "toml_datetime",
- "winnow",
-]
-
 [[package]]
 name = "typed-arena"
 version = "2.0.2"
@@ -1970,12 +1927,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"
@@ -2241,12 +2192,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.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3b801d0e0a6726477cc207f60162da452f3a95adb368399bef20a946e06f65c"
-dependencies = [
- "memchr",
-]
diff --git a/Cargo.toml b/Cargo.toml
index eecbc858..10bfdee8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,3 +8,12 @@ members = [
 ]
 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"
diff --git a/Changelog.md b/Changelog.md
index 1d02bc51..cc7b8b34 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -3,14 +3,29 @@
 
 ## 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` becomes `candid::pretty_printer`.
+    + `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.
+    + 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.
+
 ## 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.
diff --git a/rust/candid/Cargo.toml b/rust/candid/Cargo.toml
index ffb2a6b8..3f8571d8 100644
--- a/rust/candid/Cargo.toml
+++ b/rust/candid/Cargo.toml
@@ -14,28 +14,27 @@ 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"
-hex = "0.4.2"
+candid_derive = { path = "../candid_derive", version = "=0.6.5" }
 ic_principal = { path = "../ic_principal", version = "0.1.0" }
-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"
-thiserror = "1.0.20"
-anyhow = "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
+
+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]
-rand = "0.8"
+rand.workspace = true
 criterion = "0.4"
 serde_cbor = "0.11.2"
 serde_json = "1.0.74"
@@ -47,4 +46,28 @@ harness = false
 path = "benches/benchmark.rs"
 
 [features]
-mute_warnings = []
+bignum = ["num-bigint", "num-traits"]
+value = ["bignum"]
+printer = ["pretty"]
+default = ["serde_bytes", "printer", "bignum"]
+all = ["default", "value"]
+
+[[test]]
+name = "types"
+path = "tests/types.rs"
+required-features = ["value"]
+[[test]]
+name = "serde"
+path = "tests/serde.rs"
+required-features = ["bignum"]
+[[test]]
+name = "number"
+path = "tests/number.rs"
+required-features = ["bignum"]
+
+# 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/src/de.rs b/rust/candid/src/de.rs
index 036440c6..1df200e0 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,8 @@ 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")]
     pub fn get_value_with_type(
         &mut self,
         env: &TypeEnv,
@@ -136,8 +140,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 +298,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 +358,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 +382,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 +449,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 +495,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 +552,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 +583,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 +625,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 +640,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>
diff --git a/rust/candid/src/error.rs b/rust/candid/src/error.rs
index 095b8208..db663896 100644
--- a/rust/candid/src/error.rs
+++ b/rust/candid/src/error.rs
@@ -1,16 +1,21 @@
 //! `candid::Result<T> = Result<T, candid::Error>>`
 
-use codespan_reporting::diagnostic::Label;
 use serde::{de, ser};
 use std::{io, num::ParseIntError};
 use thiserror::Error;
 
 pub type Result<T = ()> = std::result::Result<T, Error>;
 
+#[derive(Debug)]
+pub struct Label {
+    range: std::ops::Range<usize>,
+    message: String,
+}
+
 #[derive(Debug, Error)]
 pub enum Error {
     #[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<()>>),
+    Binread(Vec<Label>),
 
     #[error("Subtyping error: {0}")]
     Subtype(String),
@@ -28,19 +33,25 @@ impl Error {
     }
 }
 
-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 {
+                range: pos..pos + 2,
+                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 {
+                range: pos..pos + 2,
+                message: err.to_string(),
+            }]
         }
         EnumErrors {
             pos,
@@ -52,21 +63,33 @@ 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 {
+                    range: pos..pos + 2,
+                    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 {
+                        range: pos..pos + 2,
+                        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 {
+                range: pos..pos + 2,
+                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 {
+                range: pos..pos + 2,
+                message: message.to_string(),
+            }]
         }
         Io(_) => vec![],
         _ => unreachable!(),
diff --git a/rust/candid/src/lib.rs b/rust/candid/src/lib.rs
index c4d5217a..aa40f50f 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,6 +116,8 @@
 //! 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)?;
@@ -120,7 +125,8 @@
 //! let (c, d) = Decode!(&bytes, u128, i128)?;
 //! assert_eq!(a + 1, 1025);
 //! 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,7 +178,8 @@
 //!
 //! assert_eq!(x, IDLValue::Opt(Box::new(IDLValue::Nat8(42))));
 //! assert_eq!(y, "hello");
-//! # Ok::<(), candid::Error>(())
+//! # Ok(())
+//! # }
 //! ```
 //!
 //! ## Building the library as a JS/Wasm package
@@ -229,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,
 };
 
@@ -248,9 +260,13 @@ pub mod ser;
 
 pub mod utils;
 pub use utils::{decode_args, decode_one, encode_args, encode_one, write_args};
-pub mod pretty;
 
-pub mod pretty_printer;
+#[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
diff --git a/rust/candid/src/pretty_printer.rs b/rust/candid/src/pretty/candid.rs
similarity index 94%
rename from rust/candid/src/pretty_printer.rs
rename to rust/candid/src/pretty/candid.rs
index fd513436..e143b22c 100644
--- a/rust/candid/src/pretty_printer.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] = [
@@ -160,9 +160,15 @@ pub fn pp_args(args: &[Type]) -> RcDoc {
     let doc = concat(args.iter().map(pp_ty), ",");
     enclose("(", doc, ")")
 }
-
-pub 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 super::{ident_string, pp_text};
-    use crate::pretty::*;
+    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 {
@@ -328,6 +338,13 @@ pub mod value {
                 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 100%
rename from rust/candid/src/pretty.rs
rename to rust/candid/src/pretty/utils.rs
diff --git a/rust/candid/src/ser.rs b/rust/candid/src/ser.rs
index e36e7032..994efe91 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>);
diff --git a/rust/candid/src/types/arc.rs b/rust/candid/src/types/arc.rs
index 3d8214d9..b2a682e0 100644
--- a/rust/candid/src/types/arc.rs
+++ b/rust/candid/src/types/arc.rs
@@ -5,11 +5,10 @@
 //!
 //! ```
 //! 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..6d2cb5b6 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)
     }
 }
 
@@ -140,6 +140,8 @@ where
         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()
diff --git a/rust/candid/src/types/internal.rs b/rust/candid/src/types/internal.rs
index 9c296d36..8bc7cf63 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;
@@ -232,11 +231,26 @@ impl TypeInner {
             _ => false,
         }
     }
+    pub fn is_blob(&self, env: &crate::TypeEnv) -> bool {
+        match self {
+            TypeInner::Vec(t) => {
+                let t = match env.trace_type(t) {
+                    Ok(t) => t,
+                    Err(_) => 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,14 +295,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::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::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, "{}", crate::pretty_printer::pp_ty(self).pretty(80))
+        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, "{}", crate::pretty_printer::pp_ty_inner(self).pretty(80))
+        write!(f, "{:?}", self)
     }
 }
 pub(crate) fn text_size(t: &Type, limit: i32) -> Result<i32, ()> {
@@ -375,7 +403,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}"),
         }
@@ -401,15 +429,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::pretty_printer::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`.
 ///
@@ -457,24 +493,22 @@ pub enum FuncMode {
     Query,
     CompositeQuery,
 }
-impl FuncMode {
-    pub 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::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, "{}", crate::pretty_printer::pp_function(self).pretty(80))
+        write!(f, "{:?}", self)
     }
 }
 impl Function {
@@ -518,7 +552,7 @@ macro_rules! service {
     }}
 }
 
-#[derive(Debug, PartialEq, TryFromPrimitive)]
+#[derive(Debug, PartialEq)]
 #[repr(i64)]
 pub enum Opcode {
     Null = -1,
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 75ca3de3..9b55e018 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},
@@ -88,20 +88,6 @@ impl std::str::FromStr for Nat {
     }
 }
 
-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);
-    }
-    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);
diff --git a/rust/candid/src/types/rc.rs b/rust/candid/src/types/rc.rs
index 70d48970..e2a7bf4c 100644
--- a/rust/candid/src/types/rc.rs
+++ b/rust/candid/src/types/rc.rs
@@ -5,11 +5,10 @@
 //!
 //! ```
 //! 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 85c6e334..0404a395 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::pretty_printer::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() {
                 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 => {
@@ -67,8 +97,8 @@ pub fn subtype(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result
             let fields: HashMap<_, _> = fs2.iter().map(|Field { id, ty }| (id, ty)).collect();
             for Field { id, ty: ty1 } in fs1.iter() {
                 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!(
@@ -83,7 +113,7 @@ pub fn subtype(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result
             let meths: HashMap<_, _> = ms1.iter().map(|(name, ty)| (name, ty)).collect();
             for (name, ty2) in ms2.iter() {
                 match meths.get(name) {
-                    Some(ty1) => subtype(gamma, 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}"))),
@@ -143,7 +175,8 @@ pub fn equal(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result<(
         (Opt(ty1), Opt(ty2)) => equal(gamma, env, ty1, ty2),
         (Vec(ty1), Vec(ty2)) => equal(gamma, env, ty1, ty2),
         (Record(fs1), Record(fs2)) | (Variant(fs1), Variant(fs2)) => {
-            assert_length(fs1, fs2, |x| x.to_string()).context("Different field length")?;
+            assert_length(fs1, fs2, |x| x.id.clone(), |x| x.to_string())
+                .context("Different field length")?;
             for (f1, f2) in fs1.iter().zip(fs2.iter()) {
                 if f1.id != f2.id {
                     return Err(Error::msg(format!(
@@ -159,7 +192,7 @@ pub fn equal(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result<(
             Ok(())
         }
         (Service(ms1), Service(ms2)) => {
-            assert_length(ms1, ms2, |x| format!("method {} : {}", x.0, x.1))
+            assert_length(ms1, ms2, |x| x.0.clone(), |x| format!("method {x}"))
                 .context("Different method length")?;
             for (m1, m2) in ms1.iter().zip(ms2.iter()) {
                 if m1.0 != m2.0 {
@@ -192,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)
         }
@@ -203,18 +236,19 @@ pub fn equal(gamma: &mut Gamma, env: &TypeEnv, t1: &Type, t2: &Type) -> Result<(
     }
 }
 
-fn assert_length<I, F>(left: &[I], right: &[I], display: F) -> Result<()>
+fn assert_length<I, F, K, D>(left: &[I], right: &[I], get_key: F, display: D) -> Result<()>
 where
-    F: Fn(&I) -> String,
-    I: Clone + std::hash::Hash + std::cmp::Eq,
+    F: Fn(&I) -> K + Clone,
+    K: std::hash::Hash + std::cmp::Eq,
+    D: Fn(&K) -> String,
 {
     let l = left.len();
     let r = right.len();
     if l == r {
         return Ok(());
     }
-    let left: HashSet<_> = left.iter().cloned().collect();
-    let right: HashSet<_> = right.iter().cloned().collect();
+    let left: HashSet<_> = left.iter().map(get_key.clone()).collect();
+    let right: HashSet<_> = right.iter().map(get_key).collect();
     if l < r {
         let mut diff = right.difference(&left);
         Err(Error::msg(format!(
@@ -242,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/value.rs b/rust/candid/src/types/value.rs
index ebfb0f5c..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),
@@ -189,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() {
@@ -284,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()
@@ -368,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() {
@@ -420,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] {
@@ -436,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))
@@ -449,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 be57f900..4889783f 100644
--- a/rust/candid/src/utils.rs
+++ b/rust/candid/src/utils.rs
@@ -22,6 +22,20 @@ where
     Ok(())
 }
 
+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);
+    }
+    groups.reverse();
+    if "-" == groups.first().unwrap() {
+        "-".to_string() + &groups[1..].join("_")
+    } else {
+        groups.join("_")
+    }
+}
+
 /// Encode sequence of Rust values into Candid message of type `candid::Result<Vec<u8>>`.
 #[macro_export]
 macro_rules! Encode {
diff --git a/rust/candid/tests/number.rs b/rust/candid/tests/number.rs
index ecaf1b03..48baffa5 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;
 
@@ -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,10 +77,16 @@ 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);
     }
 }
 
diff --git a/rust/candid/tests/serde.rs b/rust/candid/tests/serde.rs
index 5fb612e8..b85dd6f3 100644
--- a/rust/candid/tests/serde.rs
+++ b/rust/candid/tests/serde.rs
@@ -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;
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 dfbde3dd..5ff9d323 100644
--- a/rust/candid_derive/src/func.rs
+++ b/rust/candid_derive/src/func.rs
@@ -135,7 +135,7 @@ pub(crate) fn export_service(path: Option<TokenStream>) -> TokenStream {
             fn __export_service() -> String {
                 #service
                 #actor
-                let result = #candid::pretty_printer::compile(&env.env, &actor);
+                let result = #candid::pretty::candid::compile(&env.env, &actor);
                 format!("{}", result)
             }
         };
diff --git a/rust/candid_parser/Cargo.toml b/rust/candid_parser/Cargo.toml
index eac40b32..14cbd798 100644
--- a/rust/candid_parser/Cargo.toml
+++ b/rust/candid_parser/Cargo.toml
@@ -18,17 +18,13 @@ build = "build.rs"
 lalrpop = "0.20.0"
 
 [dependencies]
-candid = { path = "../candid", version = "0.10" }
+candid = { path = "../candid", version = "0.10", features = ["all"] }
 codespan-reporting = "0.11"
-hex = "0.4.2"
-num-bigint = { version = "0.4.2", features = ["serde"] }
-num-traits = "0.2.12"
-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"
+hex.workspace = true
+num-bigint.workspace = true
+pretty.workspace = true
+thiserror.workspace = true
+anyhow.workspace = true
 
 lalrpop-util = "0.20.0"
 logos = "0.13"
@@ -39,18 +35,18 @@ arbitrary = { version = "1.0", optional = true }
 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 }
 
-[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
 
 [features]
 configs = ["serde_dhall"]
-random = ["configs", "arbitrary", "fake", "rand"]
+random = ["configs", "arbitrary", "fake", "rand", "num-traits", "serde"]
 all = ["random"]
 
 # docs.rs-specific configuration
diff --git a/rust/candid_parser/src/bindings/javascript.rs b/rust/candid_parser/src/bindings/javascript.rs
index 6b3ecf74..02476638 100644
--- a/rust/candid_parser/src/bindings/javascript.rs
+++ b/rust/candid_parser/src/bindings/javascript.rs
@@ -1,5 +1,6 @@
 use super::analysis::{chase_actor, chase_types, infer_rec};
-use candid::pretty::*;
+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;
@@ -174,7 +175,7 @@ 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,8 +268,8 @@ pub fn compile(env: &TypeEnv, actor: &Option<Type>) -> String {
 }
 
 pub mod value {
-    use candid::pretty::*;
-    use candid::pretty_printer::value::number_to_string;
+    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;
@@ -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, "]")
@@ -358,7 +363,7 @@ pub mod value {
 pub mod test {
     use super::value;
     use crate::test::{HostAssert, HostTest, Test};
-    use candid::pretty::*;
+    use candid::pretty::utils::*;
     use candid::TypeEnv;
     use pretty::RcDoc;
 
diff --git a/rust/candid_parser/src/bindings/motoko.rs b/rust/candid_parser/src/bindings/motoko.rs
index ef4079b5..5e8a718d 100644
--- a/rust/candid_parser/src/bindings/motoko.rs
+++ b/rust/candid_parser/src/bindings/motoko.rs
@@ -1,8 +1,8 @@
 // This module implements the Candid to Motoko binding as specified in
 // https://github.com/dfinity/motoko/blob/master/design/IDL-Motoko.md
 
-use candid::pretty::*;
-use candid::pretty_printer::is_valid_as_id;
+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;
diff --git a/rust/candid_parser/src/bindings/rust.rs b/rust/candid_parser/src/bindings/rust.rs
index 256d2ef8..ee1b1b8c 100644
--- a/rust/candid_parser/src/bindings/rust.rs
+++ b/rust/candid_parser/src/bindings/rust.rs
@@ -1,5 +1,5 @@
 use super::analysis::{chase_actor, infer_rec};
-use candid::pretty::*;
+use candid::pretty::utils::*;
 use candid::types::{Field, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
 use convert_case::{Case, Casing};
 use pretty::RcDoc;
@@ -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<candid::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 {
@@ -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 = candid::pretty_printer::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_parser/src/bindings/typescript.rs b/rust/candid_parser/src/bindings/typescript.rs
index ddb4451b..594944cc 100644
--- a/rust/candid_parser/src/bindings/typescript.rs
+++ b/rust/candid_parser/src/bindings/typescript.rs
@@ -1,5 +1,5 @@
 use super::javascript::{ident, is_tuple};
-use candid::pretty::*;
+use candid::pretty::utils::*;
 use candid::types::{Field, Function, Label, SharedLabel, Type, TypeEnv, TypeInner};
 use pretty::RcDoc;
 
diff --git a/rust/candid_parser/src/grammar.lalrpop b/rust/candid_parser/src/grammar.lalrpop
index 153924f0..0951556c 100644
--- a/rust/candid_parser/src/grammar.lalrpop
+++ b/rust/candid_parser/src/grammar.lalrpop
@@ -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(<>),
diff --git a/rust/candid_parser/src/lib.rs b/rust/candid_parser/src/lib.rs
index 1cbc0e46..3953e582 100644
--- a/rust/candid_parser/src/lib.rs
+++ b/rust/candid_parser/src/lib.rs
@@ -1,5 +1,7 @@
 //! # 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.
@@ -128,6 +130,9 @@ 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;
diff --git a/rust/candid_parser/tests/parse_type.rs b/rust/candid_parser/tests/parse_type.rs
index 8608ced7..7dfb2fb6 100644
--- a/rust/candid_parser/tests/parse_type.rs
+++ b/rust/candid_parser/tests/parse_type.rs
@@ -1,4 +1,4 @@
-use candid::pretty_printer::compile;
+use candid::pretty::candid::compile;
 use candid::types::TypeEnv;
 use candid_parser::bindings::{javascript, motoko, rust, typescript};
 use candid_parser::types::IDLProg;
@@ -63,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/tools/didc/Cargo.toml b/tools/didc/Cargo.toml
index ff4399fd..bf9af2a3 100644
--- a/tools/didc/Cargo.toml
+++ b/tools/didc/Cargo.toml
@@ -5,7 +5,6 @@ authors = ["DFINITY Team"]
 edition = "2021"
 
 [dependencies]
-candid = { path = "../../rust/candid" }
 candid_parser = { path = "../../rust/candid_parser", features = ["all"] }
 clap = { version = "4.3", features = ["derive"] }
 pretty-hex = "0.2.1"
diff --git a/tools/didc/src/main.rs b/tools/didc/src/main.rs
index a13d341d..b3f8d385 100644
--- a/tools/didc/src/main.rs
+++ b/tools/didc/src/main.rs
@@ -1,11 +1,11 @@
 use anyhow::{bail, Result};
-use candid::{types::Type, 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,
+    Error, IDLArgs, IDLValue, TypeEnv,
 };
 use clap::Parser;
 use std::collections::HashSet;
@@ -172,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)?;
                         }
                     }
                     _ => {
@@ -191,14 +191,14 @@ fn main() -> Result<()> {
             };
             let ty1 = ast_to_type(&env, &ty1)?;
             let ty2 = ast_to_type(&env, &ty2)?;
-            candid::types::subtype::subtype(&mut HashSet::new(), &env, &ty1, &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_parser::bindings::javascript::compile(&env, &actor),
                 "ts" => candid_parser::bindings::typescript::compile(&env, &actor),
-                "did" => candid::pretty_printer::compile(&env, &actor),
+                "did" => candid_parser::pretty::candid::compile(&env, &actor),
                 "mo" => candid_parser::bindings::motoko::compile(&env, &actor),
                 "rs" => {
                     let config = candid_parser::bindings::rust::Config::new();
@@ -206,7 +206,7 @@ fn main() -> Result<()> {
                 }
                 "rs-agent" => {
                     let mut config = candid_parser::bindings::rust::Config::new();
-                    config.target = candid_parser::bindings::rust::Target::Agent;
+                    config.set_target(candid_parser::bindings::rust::Target::Agent);
                     candid_parser::bindings::rust::compile(&config, &env, &actor)
                 }
                 _ => unreachable!(),
@@ -228,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,
@@ -254,7 +254,7 @@ fn main() -> Result<()> {
                 "blob" => {
                     let mut res = String::new();
                     for ch in bytes.iter() {
-                        res.push_str(&candid::pretty_printer::value::pp_char(*ch));
+                        res.push_str(&candid_parser::pretty::candid::value::pp_char(*ch));
                     }
                     format!("blob \"{res}\"")
                 }
@@ -278,7 +278,6 @@ fn main() -> Result<()> {
                         .collect::<String>(),
                 )?,
                 "blob" => {
-                    use candid::types::value::IDLValue;
                     match parse_idl_value(&blob).map_err(|e| {
                         let _ = pretty_diagnose("blob", &blob, &e);
                         e