merge master, fix tests

2024-12-24 02:31:44 +03:00 · 2021-08-04 17:30:54 -07:00 · 2021-08-04 17:30:54 -07:00 · 003faed13a
commit 003faed13a
parent b35375908b 09b1fddd59
76 changed files with 936 additions and 658 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@ -5,7 +5,7 @@ commands:
    parameters:
      cache_key:
        type: string
-        default: leo-stable-cache
+        default: leo-stable-linux-cache
    steps:
      - run: set -e
      - setup_remote_docker
@ -31,7 +31,7 @@ commands:
    parameters:
      cache_key:
        type: string
-        default: leo-stable-cache
+        default: leo-stable-linux-cache
    steps:
      - run: (sccache -s||true)
      - run: set +e
@ -40,25 +40,81 @@ commands:
          paths:
            - .cache/sccache
            - .cargo
-jobs:
+# orbs:
+#   codecov: codecov/codecov@1.2.3

-  rust-stable:
+jobs:
+  check-style:
    docker:
      - image: cimg/rust:1.53
    resource_class: xlarge
    steps:
      - checkout
      - setup_environment:
-          cache_key: leo-stable-cache
+          cache_key: leo-fmt-cache
      - run:
-          name: Build and run tests
-          no_output_timeout: 30m
-          command: cargo test --all
-      - persist_to_workspace:
-          root: ~/
-          paths: project/
+          name: Check style
+          no_output_timeout: 35m
+          command: cargo fmt --all -- --check
      - clear_environment:
-          cache_key: leo-stable-cache
+          cache_key: leo-fmt-cache
+
+  clippy:
+    docker:
+      - image: cimg/rust:1.53
+    resource_class: xlarge
+    steps:
+      - checkout
+      - setup_environment:
+          cache_key: leo-clippy-cache
+      - run:
+          name: Clippy
+          no_output_timeout: 35m
+          command: cargo clippy --all-features --examples --all --benches
+      - clear_environment:
+          cache_key: leo-clippy-cache
+          
+  # code-cov:
+  #   docker:
+  #     - image: cimg/rust:1.53.0
+  #   resource_class: xlarge
+  #   environment:
+  #     RUSTC_BOOTSTRAP: 1
+  #   steps:
+  #     - checkout
+  #     - setup_environment:
+  #         cache_key: leo-codecov-cache
+  #     - run:
+  #         name: Build and run tests
+  #         no_output_timeout: 30m
+  #         command: cargo test --all
+  #     - run:
+  #         name: Install Code Cov Deps
+  #         no_output_timeout: 30m
+  #         command: |
+  #           sudo apt-get update
+  #           sudo apt-get -y install binutils-dev libcurl4-openssl-dev zlib1g-dev libdw-dev libiberty-dev
+  #     - run:
+  #         name: Generate Coverage Report
+  #         no_output_timeout: 30m
+  #         command: |
+  #           wget https://github.com/SimonKagstrom/kcov/archive/master.tar.gz
+  #           tar xzf master.tar.gz
+  #           cd kcov-master
+  #           mkdir build && cd build
+  #           cmake .. && make
+  #           make install DESTDIR=../../kcov-build
+  #           cd ../..
+  #           rm -rf kcov-master
+  #           for file in target/debug/deps/*-*; do if [[ "$file" != *\.* ]]; then mkdir -p "target/cov/$(basename $file)"; ./kcov-build/usr/local/bin/kcov --exclude-pattern=/.cargo,/usr/lib --exclude-region='@kcov_skip(start):@kcov_skip(end)' --verify "target/cov/$(basename $file)" "$file"; fi done
+  #     steps:
+  #     - codecov/upload:
+  #         file: {{}}
+  #     - persist_to_workspace:
+  #         root: ~/
+  #         paths: project/
+  #     - clear_environment:
+  #         cache_key: leo-codecov-cache

  leo-executable:
    docker:
@ -199,7 +255,8 @@ workflows:
  version: 2
  main-workflow:
    jobs:
-      - rust-stable
+      - check-style
+      - clippy
      - leo-executable
      - leo-new:
          requires:
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@ -5,7 +5,7 @@ updates:
  schedule:
    interval: daily
    time: "10:00"
-  open-pull-requests-limit: 10
+  open-pull-requests-limit: 20
  ignore:
  - dependency-name: snarkvm-curves
    versions:
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -13,80 +13,85 @@ env:
  RUST_BACKTRACE: 1

 jobs:
-  style:
-    name: Check Style
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v1
-
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: nightly
-          override: true
-          components: rustfmt
-
-      - name: cargo fmt --check
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
-  clippy:
-    name: Clippy
-    runs-on: ubuntu-latest
+  test-package:
+    name: Test Package ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [macOS-latest, windows-latest, ubuntu-latest]
+        include:
+          - os: ubuntu-latest
+            sccache-path: /home/runner/.cache/sccache
+          - os: macos-latest
+            sccache-path: /Users/runner/Library/Caches/Mozilla.sccache
+          - os: windows-latest
+            sccache-path: "C:\\Users\\runneradmin\\AppData\\Local\\Mozilla\\sccache"
    env:
-      RUSTFLAGS: -Dwarnings
+      RUSTC_WRAPPER: sccache
+      SCCACHE_CACHE_SIZE: 2G
+      SCCACHE_DIR: ${{ matrix.sccache-path }}
+      # SCCACHE_RECACHE: 1 # Uncomment this to clear cache, then comment it back out
    steps:
      - name: Checkout
        uses: actions/checkout@v2

-      - name: Install Rust
+      - name: Install sccache Ubuntu
+        if: matrix.os == 'ubuntu-latest'
+        env:
+          LINK: https://github.com/mozilla/sccache/releases/download
+          SCCACHE_VERSION: v0.2.15
+        run: |
+          SCCACHE_FILE=sccache-$SCCACHE_VERSION-x86_64-unknown-linux-musl
+          mkdir -p $HOME/.local/bin
+          curl -L "$LINK/$SCCACHE_VERSION/$SCCACHE_FILE.tar.gz" | tar xz
+          mv -f $SCCACHE_FILE/sccache $HOME/.local/bin/sccache
+          chmod +x $HOME/.local/bin/sccache
+          echo "$HOME/.local/bin" >> $GITHUB_PATH
+      
+      - name: Install sccache Macos
+        if: matrix.os == 'macos-latest'
+        run: |
+          brew update
+          brew install sccache
+
+      - name: Install sccache Windows
+        if: matrix.os == 'windows-latest'
+        run: |
+          iwr -useb get.scoop.sh | iex
+          Set-ExecutionPolicy RemoteSigned -scope CurrentUser
+          scoop install sccache
+          echo "C:\Users\runneradmin\scoop\shims" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+
+      - name: Install Rust Stable
        uses: actions-rs/toolchain@v1
        with:
          profile: minimal
          toolchain: stable
          override: true
-          components: clippy

-      - name: Check examples
-        uses: actions-rs/cargo@v1
+      - name: Cache cargo registry
+        uses: actions/cache@v2
+        continue-on-error: false
        with:
-          command: clippy
-          args: --examples --all
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-
            
-      - name: Check examples with all features on stable
-        uses: actions-rs/cargo@v1
+      - name: Save sccache
+        uses: actions/cache@v2
+        continue-on-error: false
        with:
-          command: clippy
-          args: --examples --all-features --all
+          path: ${{ matrix.sccache-path }}
+          key: ${{ runner.os }}-sccache-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-sccache-
            
-      - name: Check benchmarks on nightly
-        uses: actions-rs/cargo@v1
-        with:
-          command: clippy
-          args: --all-features --examples --all --benches
-
-  test-package:
-    name: Test Package
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        rust:
-          - stable
-          - nightly
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Install Rust (${{ matrix.rust }})
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: ${{ matrix.rust }}
-          override: true
+      - name: Start sccache server
+        run: |
+          sccache --start-server

      - name: Install cargo-all-features
        run: |
@ -97,21 +102,138 @@ jobs:
          cd package
          cargo test-all-features

-  codecov:
-    name: Code Coverage
-    runs-on: ubuntu-latest
+      - name: Print sccache stats
+        run: sccache --show-stats
+        
+      - name: Stop sccache server
+        run: sccache --stop-server || true
+
+  test-package-macos_m1:
+    name: Test Package macOS M1
+    runs-on: macos-latest
+    env:
+      RUSTC_WRAPPER: sccache
+      SCCACHE_CACHE_SIZE: 2G
+      SCCACHE_DIR: /Users/runner/Library/Caches/Mozilla.sccache
    steps:
+      - name: Xcode Select
+        uses: devbotsxyz/xcode-select@v1.1.0
+
      - name: Checkout
-        uses: actions/checkout@v1
+        uses: actions/checkout@v2
+
+      - name: Install sccache
+        run: |
+          brew update
+          brew install sccache
        
      - name: Install Rust
        uses: actions-rs/toolchain@v1
        with:
          profile: minimal
-          toolchain: nightly
+          target: aarch64-apple-darwin
+          toolchain: stable
          override: true
          components: rustfmt

+      - name: Cache cargo registry
+        uses: actions/cache@v2
+        continue-on-error: false
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+          key: m1-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            m1-cargo-
+            
+      - name: Save sccache
+        uses: actions/cache@v2
+        continue-on-error: false
+        with:
+          path: /Users/runner/Library/Caches/Mozilla.sccache
+          key: m1-sccache-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            m1-sccache-
+            
+      - name: Start sccache server
+        run: |
+          sccache --start-server
+          
+      - name: Install cargo-all-features
+        run: |
+          SDKROOT=$(xcrun -sdk macosx11.1 --show-sdk-path) \
+          MACOSX_DEPLOYMENT_TARGET=$(xcrun -sdk macosx11.1 --show-sdk-platform-version) \
+          cargo install cargo-all-features
+          
+      - name: Test
+        run: |
+          SDKROOT=$(xcrun -sdk macosx11.1 --show-sdk-path) \
+          MACOSX_DEPLOYMENT_TARGET=$(xcrun -sdk macosx11.1 --show-sdk-platform-version) \
+          cd package && cargo test-all-features
+
+      - name: Print sccache stats
+        run: sccache --show-stats
+        
+      - name: Stop sccache server
+        run: sccache --stop-server || true
+
+  codecov:
+    name: Code Coverage
+    runs-on: ubuntu-latest
+    env:
+      RUSTC_BOOTSTRAP: 1
+      RUSTC_WRAPPER: sccache
+      SCCACHE_CACHE_SIZE: 2G
+      SCCACHE_DIR: /home/runner/.cache/sccache
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Install sccache Ubuntu
+        env:
+          LINK: https://github.com/mozilla/sccache/releases/download
+          SCCACHE_VERSION: v0.2.15
+        run: |
+          SCCACHE_FILE=sccache-$SCCACHE_VERSION-x86_64-unknown-linux-musl
+          mkdir -p $HOME/.local/bin
+          curl -L "$LINK/$SCCACHE_VERSION/$SCCACHE_FILE.tar.gz" | tar xz
+          mv -f $SCCACHE_FILE/sccache $HOME/.local/bin/sccache
+          chmod +x $HOME/.local/bin/sccache
+          echo "$HOME/.local/bin" >> $GITHUB_PATH
+        
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+          components: rustfmt
+
+      - name: Cache cargo registry
+        uses: actions/cache@v2
+        continue-on-error: false
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+          key: codecov-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            codecov-cargo-
+            
+      - name: Save sccache
+        uses: actions/cache@v2
+        continue-on-error: false
+        with:
+          path: /Users/runner/Library/Caches/Mozilla.sccache
+          key: codecov-sccache-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            codecov-sccache-
+            
+      - name: Start sccache server
+        run: |
+          sccache --start-server
+
      - name: Test
        uses: actions-rs/cargo@v1
        with:
@ -142,3 +264,9 @@ jobs:
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          token: ${{ secrets.CODECOV_TOKEN }}
+
+      - name: Print sccache stats
+        run: sccache --show-stats
+        
+      - name: Stop sccache server
+        run: sccache --stop-server || true
--- a/.rustfmt.toml
+++ b/.rustfmt.toml
@ -8,9 +8,9 @@ use_field_init_shorthand = true
 use_try_shorthand = true

 # Nightly configurations
-imports_layout = "HorizontalVertical"
-license_template_path = ".resources/license_header"
-imports_granularity = "Crate"
-overflow_delimited_expr = true
-reorder_impl_items = true
-version = "Two"
+# imports_layout = "HorizontalVertical"
+# license_template_path = ".resources/license_header"
+# imports_granularity = "Crate"
+# overflow_delimited_expr = true
+# reorder_impl_items = true
+# version = "Two"
--- a/Cargo.lock
+++ b/Cargo.lock
@ -88,9 +88,9 @@ checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"

 [[package]]
 name = "assert_cmd"
-version = "1.0.7"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d20831bd004dda4c7c372c19cdabff369f794a95e955b3f13fe460e3e1ae95f"
+checksum = "c98233c6673d8601ab23e77eb38f999c51100d46c5703b17288c57fddf3a1ffe"
 dependencies = [
 "bstr",
 "doc-comment",
@ -281,7 +281,7 @@ version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4c24dab4283a142afa2fdca129b80ad2c6284e073930f964c3a1293c225ee39a"
 dependencies = [
- "rustc_version 0.4.0",
+ "rustc_version",
 ]

 [[package]]
@ -1205,7 +1205,6 @@ dependencies = [
 "serde",
 "serde_json",
 "tendril",
- "thiserror",
 "typed-arena",
 ]

@ -1293,7 +1292,6 @@ dependencies = [
 "leo-ast",
 "leo-errors",
 "leo-parser",
- "thiserror",
 "tracing",
 ]

@ -1346,7 +1344,6 @@ dependencies = [
 "snarkvm-utilities",
 "structopt",
 "test_dir",
- "thiserror",
 "toml",
 "tracing",
 "tracing-subscriber",
@ -1402,7 +1399,6 @@ dependencies = [
 "snarkvm-curves",
 "snarkvm-dpc",
 "snarkvm-utilities",
- "thiserror",
 ]

 [[package]]
@ -2237,15 +2233,6 @@ version = "0.1.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dead70b0b5e03e9c814bcb6b01e03e68f7c57a80aa48c72ec92152ab3e818d49"

-[[package]]
-name = "rustc_version"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0dfe2087c51c460008730de8b57e6a320782fbfb312e1f4d520e6c6fae155ee"
-dependencies = [
- "semver 0.11.0",
-]
-
 [[package]]
 name = "rustc_version"
 version = "0.4.0"
@ -2365,9 +2352,9 @@ dependencies = [

 [[package]]
 name = "serde"
-version = "1.0.126"
+version = "1.0.127"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec7505abeacaec74ae4778d9d9328fe5a5d04253220a85c4ee022239fc996d03"
+checksum = "f03b9878abf6d14e6779d3f24f07b2cfa90352cfec4acc5aab8f1ac7f146fae8"
 dependencies = [
 "serde_derive",
 ]
@ -2384,9 +2371,9 @@ dependencies = [

 [[package]]
 name = "serde_derive"
-version = "1.0.126"
+version = "1.0.127"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "963a7dbc9895aeac7ac90e74f34a5d5261828f79df35cbed41e10189d3804d43"
+checksum = "a024926d3432516606328597e0f224a51355a493b49fdd67e9209187cbe55ecc"
 dependencies = [
 "proc-macro2 1.0.27",
 "quote 1.0.9",
@ -2485,9 +2472,9 @@ checksum = "fe0f37c9e8f3c5a4a66ad655a93c74daac4ad00c441533bf5c6e7990bb42604e"

 [[package]]
 name = "snarkvm-algorithms"
-version = "0.7.5"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8bbefe6252ed85bb073f8ecbc402830e3d119b1aaadcea5a9c9e7a21a99cd2"
+checksum = "7ceaacc1e52860b05cef025f5f7eea8179ba1327c5203008e938ba3aa50cd676"
 dependencies = [
 "anyhow",
 "bitvec",
@ -2513,14 +2500,14 @@ dependencies = [

 [[package]]
 name = "snarkvm-curves"
-version = "0.7.5"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62fdf07998a6e88fce7a8139e8282fb6b2702e49624b6d7e10a5cc1c9f014264"
+checksum = "7cb586a9383563b62120e788f8d9200cfcd5a5b610c2723403a72e6b4cc7ee71"
 dependencies = [
 "derivative",
 "rand 0.8.4",
 "rand_xorshift",
- "rustc_version 0.3.3",
+ "rustc_version",
 "serde",
 "snarkvm-fields",
 "snarkvm-utilities",
@ -2529,9 +2516,9 @@ dependencies = [

 [[package]]
 name = "snarkvm-derives"
-version = "0.7.5"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d42f4d5abda149130149ce3865aef23d380dfcdd97fea7f75fd79b0aee369b29"
+checksum = "ec9f9134f9b06f279312d39a41c23fcc9ab29e987e74fc1e97a0945d1d169ff0"
 dependencies = [
 "proc-macro-crate",
 "proc-macro-error",
@ -2542,9 +2529,9 @@ dependencies = [

 [[package]]
 name = "snarkvm-dpc"
-version = "0.7.5"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af8dd1b815a1101c4014c17cbdffadecb1032e8662fdf5fd4bd67a3c149d8449"
+checksum = "acfc9ca513d8772a2b4f2e2596751bb427fc2a4c1942b4db79f54f15a41aa448"
 dependencies = [
 "anyhow",
 "base58",
@ -2574,9 +2561,9 @@ dependencies = [

 [[package]]
 name = "snarkvm-fields"
-version = "0.7.5"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ecd058b3608140610276be1eb1139a032a1bb171969b3ad70550c471d3ae503"
+checksum = "8a0717dbbf3e92e12084c913e53b21534270d2d00584a4344453af1c66952bee"
 dependencies = [
 "anyhow",
 "bincode",
@ -2590,9 +2577,9 @@ dependencies = [

 [[package]]
 name = "snarkvm-gadgets"
-version = "0.7.5"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b462bb5e5ac219eafd1a828c73c181e7b23692ade5c49fd72d71bfe4250a6b1"
+checksum = "856e8e5aeaf1b5eccb1726bef4878ab4445977337cc35f63fc9172afee80d716"
 dependencies = [
 "derivative",
 "digest 0.9.0",
@ -2610,9 +2597,9 @@ dependencies = [

 [[package]]
 name = "snarkvm-marlin"
-version = "0.7.5"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e5b1bb7923a757053c0a544072ec6b298585f83c9f4a3ae777ca048bb6e5589"
+checksum = "9f426c842d30a47192a18aedcd84f5a892c0e491eca1e953899ab3363b7a9d14"
 dependencies = [
 "blake2",
 "derivative",
@ -2634,9 +2621,9 @@ dependencies = [

 [[package]]
 name = "snarkvm-parameters"
-version = "0.7.5"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14356edda788a3e52ac6e809e6fdbfd5cf7558249bf6051525843b045a73d12a"
+checksum = "7da1fcd3d64f7480bbcfe2dfa86600d4d993a4d6fce006b99ea1b5edbd940df7"
 dependencies = [
 "curl",
 "hex",
@ -2647,9 +2634,9 @@ dependencies = [

 [[package]]
 name = "snarkvm-polycommit"
-version = "0.7.5"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28fac50de72680316fe57fbbbde2874ae28de7191a3f23ff9e541119951ddaa8"
+checksum = "513d200b3ec60bc9e5dd40293ac604781c1e0dbb383a3092146e06e37e440aab"
 dependencies = [
 "derivative",
 "digest 0.9.0",
@ -2666,15 +2653,15 @@ dependencies = [

 [[package]]
 name = "snarkvm-profiler"
-version = "0.7.5"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ebfa546f0376a1348b857a9defdb3f4505a0420d82f8caa2b0cebbe197245fa"
+checksum = "bc70acae38d1827eb81d9888791517cc5105b49c23c7b567f7c284145eb10c63"

 [[package]]
 name = "snarkvm-r1cs"
-version = "0.7.5"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2aca9bb7105244ebc91f964b11a1ae63f173a77181307d1fa94f04e15dbde137"
+checksum = "749b0a504b8421b5d399893834bb0f9d1acf5c43769412b5c826381998c8a1e4"
 dependencies = [
 "cfg-if 1.0.0",
 "fxhash",
@ -2687,9 +2674,9 @@ dependencies = [

 [[package]]
 name = "snarkvm-utilities"
-version = "0.7.5"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15b7ecf6a7afdd60a45cbd5ffab75185c296d8a4bf5eb20f3912384b1d4027c2"
+checksum = "1cc0611d450dfd4e9ad305dd343c0420430f83c73cdb79f6e6e184848dc3e2ee"
 dependencies = [
 "anyhow",
 "bincode",
--- a/Cargo.toml
+++ b/Cargo.toml
@ -79,22 +79,22 @@ path = "./synthesizer"
 version = "1.5.3"

 [dependencies.snarkvm-algorithms]
-version = "0.7.4"
+version = "0.7.6"

 [dependencies.snarkvm-curves]
-version = "0.7.5"
+version = "0.7.7"
 default-features = false

 [dependencies.snarkvm-gadgets]
-version = "0.7.5"
+version = "0.7.7"
 default-features = false

 [dependencies.snarkvm-r1cs]
-version = "0.7.5"
+version = "0.7.7"
 default-features = false

 [dependencies.snarkvm-utilities]
-version = "0.7.4"
+version = "0.7.6"

 [dependencies.structopt]
 version = "0.3"
@ -144,9 +144,6 @@ features = [ "derive" ]
 [dependencies.serde_json]
 version = "1.0"

-[dependencies.thiserror]
-version = "1.0"
-
 [dependencies.toml]
 version = "0.5"

@ -167,7 +164,7 @@ version = "0.12.1"
 version = "0.11.2"

 [dev-dependencies.assert_cmd]
-version = "1.0.7"
+version = "1.0.8"

 [dev-dependencies.test_dir]
 version = "0.1.0"
--- a/asg/Cargo.toml
+++ b/asg/Cargo.toml
@ -26,9 +26,6 @@ version = "1.0"
 [dependencies.indexmap]
 version = "1.7"

-[dependencies.thiserror]
-version = "1.0"
-
 [dependencies.leo-ast]
 version = "1.5.3"
 path = "../ast"
--- a/asg/src/expression/call.rs
+++ b/asg/src/expression/call.rs
@ -15,17 +15,8 @@
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.

 use crate::{
-    CircuitMember,
-    ConstValue,
-    Expression,
-    ExpressionNode,
-    FromAst,
-    Function,
-    FunctionQualifier,
-    Node,
-    PartialType,
-    Scope,
-    Type,
+    CircuitMember, ConstValue, Expression, ExpressionNode, FromAst, Function, FunctionQualifier, Node, PartialType,
+    Scope, Type,
 };
 pub use leo_ast::{BinaryOperation, Node as AstNode};
 use leo_errors::{AsgError, Result, Span};
--- a/asg/src/expression/circuit_access.rs
+++ b/asg/src/expression/circuit_access.rs
@ -15,17 +15,7 @@
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.

 use crate::{
-    Circuit,
-    CircuitMember,
-    ConstValue,
-    Expression,
-    ExpressionNode,
-    FromAst,
-    Identifier,
-    Node,
-    PartialType,
-    Scope,
-    Type,
+    Circuit, CircuitMember, ConstValue, Expression, ExpressionNode, FromAst, Identifier, Node, PartialType, Scope, Type,
 };

 use leo_errors::{AsgError, Result, Span};
--- a/asg/src/expression/circuit_init.rs
+++ b/asg/src/expression/circuit_init.rs
@ -15,17 +15,7 @@
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.

 use crate::{
-    Circuit,
-    CircuitMember,
-    ConstValue,
-    Expression,
-    ExpressionNode,
-    FromAst,
-    Identifier,
-    Node,
-    PartialType,
-    Scope,
-    Type,
+    Circuit, CircuitMember, ConstValue, Expression, ExpressionNode, FromAst, Identifier, Node, PartialType, Scope, Type,
 };

 use leo_errors::{AsgError, Result, Span};
--- a/asg/src/expression/constant.rs
+++ b/asg/src/expression/constant.rs
@ -15,17 +15,7 @@
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.

 use crate::{
-    CharValue,
-    ConstInt,
-    ConstValue,
-    Expression,
-    ExpressionNode,
-    FromAst,
-    GroupValue,
-    Node,
-    PartialType,
-    Scope,
-    Type,
+    CharValue, ConstInt, ConstValue, Expression, ExpressionNode, FromAst, GroupValue, Node, PartialType, Scope, Type,
 };

 use leo_errors::{AsgError, Result, Span};
@ -150,9 +140,7 @@ impl<'a> FromAst<'a, leo_ast::ValueExpression> for Constant<'a> {
                    span: Some(value.span().clone()),
                    value: ConstValue::Group(match &**value {
                        leo_ast::GroupValue::Single(value, _) => GroupValue::Single(value.clone()),
-                        leo_ast::GroupValue::Tuple(tuple) => {
-                            let x = &tuple.x;
-                            let y = &tuple.y;
+                        leo_ast::GroupValue::Tuple(leo_ast::GroupTuple { x, y, .. }) => {
                            GroupValue::Tuple(x.into(), y.into())
                        }
                    }),
@ -234,11 +222,11 @@ impl<'a> Into<leo_ast::ValueExpression> for &Constant<'a> {
                GroupValue::Single(single) => {
                    leo_ast::GroupValue::Single(single.clone(), self.span.clone().unwrap_or_default())
                }
-                GroupValue::Tuple(left, right) => leo_ast::GroupValue::Tuple(Box::new(leo_ast::GroupTuple {
+                GroupValue::Tuple(left, right) => leo_ast::GroupValue::Tuple(leo_ast::GroupTuple {
                    x: left.into(),
                    y: right.into(),
                    span: self.span.clone().unwrap_or_default(),
-                })),
+                }),
            })),
            ConstValue::Int(int) => leo_ast::ValueExpression::Integer(
                int.get_int_type(),
--- a/asg/src/expression/variable_ref.rs
+++ b/asg/src/expression/variable_ref.rs
@ -15,18 +15,8 @@
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.

 use crate::{
-    ConstValue,
-    Constant,
-    DefinitionStatement,
-    Expression,
-    ExpressionNode,
-    FromAst,
-    Node,
-    PartialType,
-    Scope,
-    Statement,
-    Type,
-    Variable,
+    ConstValue, Constant, DefinitionStatement, Expression, ExpressionNode, FromAst, Node, PartialType, Scope,
+    Statement, Type, Variable,
 };

 use leo_errors::{AsgError, Result, Span};
--- a/asg/src/program/circuit.rs
+++ b/asg/src/program/circuit.rs
@ -150,7 +150,7 @@ impl<'a> Into<leo_ast::Circuit> for &Circuit<'a> {
                CircuitMember::Variable(type_) => {
                    leo_ast::CircuitMember::CircuitVariable(Identifier::new((&**name).into()), type_.into())
                }
-                CircuitMember::Function(func) => leo_ast::CircuitMember::CircuitFunction(Box::new((*func).into())),
+                CircuitMember::Function(func) => leo_ast::CircuitMember::CircuitFunction((*func).into()),
            })
            .collect();
        leo_ast::Circuit {
--- a/asg/src/program/function.rs
+++ b/asg/src/program/function.rs
@ -15,16 +15,7 @@
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.

 use crate::{
-    BlockStatement,
-    Circuit,
-    FromAst,
-    Identifier,
-    MonoidalDirector,
-    ReturnPathReducer,
-    Scope,
-    Statement,
-    Type,
-    Variable,
+    BlockStatement, Circuit, FromAst, Identifier, MonoidalDirector, ReturnPathReducer, Scope, Statement, Type, Variable,
 };
 use indexmap::IndexMap;
 pub use leo_ast::Annotation;
@ -177,13 +168,13 @@ impl<'a> Into<leo_ast::Function> for &Function<'a> {
            .iter()
            .map(|(_, variable)| {
                let variable = variable.get().borrow();
-                leo_ast::FunctionInput::Variable(Box::new(leo_ast::FunctionInputVariable {
+                leo_ast::FunctionInput::Variable(leo_ast::FunctionInputVariable {
                    identifier: variable.name.clone(),
                    mutable: variable.mutable,
                    const_: variable.const_,
                    type_: (&variable.type_).into(),
                    span: Span::default(),
-                }))
+                })
            })
            .collect();
        let (body, span) = match self.body.get() {
--- a/asg/src/statement/assign.rs
+++ b/asg/src/statement/assign.rs
@ -15,20 +15,8 @@
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.

 use crate::{
-    CircuitMember,
-    ConstInt,
-    ConstValue,
-    Expression,
-    ExpressionNode,
-    FromAst,
-    Identifier,
-    IntegerType,
-    Node,
-    PartialType,
-    Scope,
-    Statement,
-    Type,
-    Variable,
+    CircuitMember, ConstInt, ConstValue, Expression, ExpressionNode, FromAst, Identifier, IntegerType, Node,
+    PartialType, Scope, Statement, Type, Variable,
 };
 pub use leo_ast::AssignOperation;
 use leo_ast::AssigneeAccess as AstAssigneeAccess;
--- a/asg/src/statement/definition.rs
+++ b/asg/src/statement/definition.rs
@ -32,12 +32,15 @@ impl<'a> DefinitionStatement<'a> {
        self.variables
            .iter()
            .map(|variable| {
-                (variable.borrow().name.name.to_string(), DefinitionStatement {
+                (
+                    variable.borrow().name.name.to_string(),
+                    DefinitionStatement {
                        parent: self.parent.clone(),
                        span: self.span.clone(),
                        variables: vec![variable],
                        value: self.value.clone(),
-                })
+                    },
+                )
            })
            .collect()
    }
--- a/ast/src/circuits/circuit_member.rs
+++ b/ast/src/circuits/circuit_member.rs
@ -24,7 +24,7 @@ pub enum CircuitMember {
    // (variable_name, variable_type)
    CircuitVariable(Identifier, Type),
    // (function)
-    CircuitFunction(Box<Function>),
+    CircuitFunction(Function),
 }

 impl fmt::Display for CircuitMember {
--- a/ast/src/common/identifier.rs
+++ b/ast/src/common/identifier.rs
@ -21,13 +21,9 @@ use tendril::StrTendril;
 use crate::Node;
 use serde::{
    de::{
-        Visitor,
-        {self},
+        Visitor, {self},
    },
-    Deserialize,
-    Deserializer,
-    Serialize,
-    Serializer,
+    Deserialize, Deserializer, Serialize, Serializer,
 };
 use std::{
    collections::BTreeMap,
--- a/ast/src/expression/mod.rs
+++ b/ast/src/expression/mod.rs
@ -15,13 +15,7 @@
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.

 use crate::{
-    ArrayDimensions,
-    CircuitImpliedVariableDefinition,
-    GroupValue,
-    Identifier,
-    IntegerType,
-    Node,
-    PositiveNumber,
+    ArrayDimensions, CircuitImpliedVariableDefinition, GroupValue, Identifier, IntegerType, Node, PositiveNumber,
    SpreadOrExpression,
 };

--- a/ast/src/functions/input/input_variable.rs
+++ b/ast/src/functions/input/input_variable.rs
@ -25,8 +25,8 @@ use std::fmt;
 pub enum FunctionInput {
    SelfKeyword(SelfKeyword),
    ConstSelfKeyword(ConstSelfKeyword),
-    MutSelfKeyword(Box<MutSelfKeyword>),
-    Variable(Box<FunctionInputVariable>),
+    MutSelfKeyword(MutSelfKeyword),
+    Variable(FunctionInputVariable),
 }

 impl FunctionInput {
--- a/ast/src/groups/group_coordinate.rs
+++ b/ast/src/groups/group_coordinate.rs
@ -16,11 +16,8 @@

 use leo_errors::Span;
 use leo_input::values::{
-    GroupCoordinate as InputGroupCoordinate,
-    Inferred as InputInferred,
-    NumberValue as InputNumberValue,
-    SignHigh as InputSignHigh,
-    SignLow as InputSignLow,
+    GroupCoordinate as InputGroupCoordinate, Inferred as InputInferred, NumberValue as InputNumberValue,
+    SignHigh as InputSignHigh, SignLow as InputSignLow,
 };

 use serde::{Deserialize, Serialize};
--- a/ast/src/groups/group_value.rs
+++ b/ast/src/groups/group_value.rs
@ -17,9 +17,7 @@
 use crate::groups::GroupCoordinate;
 use leo_errors::Span;
 use leo_input::values::{
-    GroupRepresentation as InputGroupRepresentation,
-    GroupTuple as InputGroupTuple,
-    GroupValue as InputGroupValue,
+    GroupRepresentation as InputGroupRepresentation, GroupTuple as InputGroupTuple, GroupValue as InputGroupValue,
 };

 use serde::{Deserialize, Serialize};
@ -29,7 +27,7 @@ use tendril::StrTendril;
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum GroupValue {
    Single(#[serde(with = "crate::common::tendril_json")] StrTendril, Span),
-    Tuple(Box<GroupTuple>),
+    Tuple(GroupTuple),
 }

 impl GroupValue {
@ -54,7 +52,7 @@ impl<'ast> From<InputGroupValue<'ast>> for GroupValue {

        match ast_group.value {
            InputGroupRepresentation::Single(number) => GroupValue::Single(number.to_string().into(), span),
-            InputGroupRepresentation::Tuple(tuple) => GroupValue::Tuple(Box::new(GroupTuple::from(tuple))),
+            InputGroupRepresentation::Tuple(tuple) => GroupValue::Tuple(GroupTuple::from(tuple)),
        }
    }
 }
--- a/ast/src/imports/package_access.rs
+++ b/ast/src/imports/package_access.rs
@ -24,7 +24,7 @@ use std::fmt;
 pub enum PackageAccess {
    Star { span: Span },
    SubPackage(Box<Package>),
-    Symbol(Box<ImportSymbol>),
+    Symbol(ImportSymbol),
    Multiple(Packages),
 }

--- a/ast/src/input/input_value.rs
+++ b/ast/src/input/input_value.rs
@ -21,15 +21,8 @@ use leo_input::{
    expressions::{ArrayInitializerExpression, ArrayInlineExpression, Expression, StringExpression, TupleExpression},
    types::{ArrayType, CharType, DataType, IntegerType, TupleType, Type},
    values::{
-        Address,
-        AddressValue,
-        BooleanValue,
-        CharValue as InputCharValue,
-        FieldValue,
-        GroupValue as InputGroupValue,
-        IntegerValue,
-        NumberValue,
-        Value,
+        Address, AddressValue, BooleanValue, CharValue as InputCharValue, FieldValue, GroupValue as InputGroupValue,
+        IntegerValue, NumberValue, Value,
    },
 };
 use pest::Span;
@ -42,7 +35,7 @@ pub enum InputValue {
    Boolean(bool),
    Char(CharValue),
    Field(String),
-    Group(Box<GroupValue>),
+    Group(GroupValue),
    Integer(IntegerType, String),
    Array(Vec<InputValue>),
    Tuple(Vec<InputValue>),
@ -80,7 +73,7 @@ impl InputValue {
    }

    fn from_group(group: InputGroupValue) -> Self {
-        InputValue::Group(Box::new(GroupValue::from(group)))
+        InputValue::Group(GroupValue::from(group))
    }

    fn from_field(field: FieldValue) -> Self {
--- a/ast/src/input/program_state/public_state/public_state.rs
+++ b/ast/src/input/program_state/public_state/public_state.rs
@ -40,7 +40,11 @@ impl PublicState {
    }

    pub fn len(&self) -> usize {
-        if self.state.is_present() { 1usize } else { 0usize }
+        if self.state.is_present() {
+            1usize
+        } else {
+            0usize
+        }
    }

    /// Parse all input variables included in a file and store them in `self`.
--- a/ast/src/reducer/canonicalization.rs
+++ b/ast/src/reducer/canonicalization.rs
@ -441,14 +441,14 @@ impl Canonicalizer {
                    output = Some(Type::Circuit(self.circuit_name.as_ref().unwrap().clone()));
                }

-                return CircuitMember::CircuitFunction(Box::new(Function {
+                return CircuitMember::CircuitFunction(Function {
                    annotations: function.annotations.clone(),
                    identifier: function.identifier.clone(),
                    input,
                    output,
                    block,
                    span: function.span.clone(),
-                }));
+                });
            }
        }

--- a/ast/src/reducer/reconstructing_director.rs
+++ b/ast/src/reducer/reconstructing_director.rs
@ -92,7 +92,7 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {

    pub fn reduce_group_value(&mut self, group_value: &GroupValue) -> Result<GroupValue> {
        let new = match group_value {
-            GroupValue::Tuple(group_tuple) => GroupValue::Tuple(Box::new(self.reduce_group_tuple(group_tuple)?)),
+            GroupValue::Tuple(group_tuple) => GroupValue::Tuple(self.reduce_group_tuple(group_tuple)?),
            _ => group_value.clone(),
        };

@ -454,7 +454,7 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
    pub fn reduce_function_input(&mut self, input: &FunctionInput) -> Result<FunctionInput> {
        let new = match input {
            FunctionInput::Variable(function_input_variable) => {
-                FunctionInput::Variable(Box::new(self.reduce_function_input_variable(function_input_variable)?))
+                FunctionInput::Variable(self.reduce_function_input_variable(function_input_variable)?)
            }
            _ => input.clone(),
        };
@ -491,9 +491,7 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
                self.reduce_identifier(identifier)?,
                self.reduce_type(type_, &identifier.span)?,
            ),
-            CircuitMember::CircuitFunction(function) => {
-                CircuitMember::CircuitFunction(Box::new(self.reduce_function(function)?))
-            }
+            CircuitMember::CircuitFunction(function) => CircuitMember::CircuitFunction(self.reduce_function(function)?),
        };

        self.reducer.reduce_circuit_member(circuit_member, new)
--- a/ast/src/types/integer_type.rs
+++ b/ast/src/types/integer_type.rs
@ -15,8 +15,7 @@
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.

 use leo_input::types::{
-    IntegerType as InputIntegerType,
-    SignedIntegerType as InputSignedIntegerType,
+    IntegerType as InputIntegerType, SignedIntegerType as InputSignedIntegerType,
    UnsignedIntegerType as InputUnsignedIntegerType,
 };

--- a/ast/src/types/type_.rs
+++ b/ast/src/types/type_.rs
@ -16,10 +16,7 @@

 use crate::{ArrayDimensions, Identifier, IntegerType};
 use leo_input::types::{
-    ArrayType as InputArrayType,
-    DataType as InputDataType,
-    TupleType as InputTupleType,
-    Type as InputType,
+    ArrayType as InputArrayType, DataType as InputDataType, TupleType as InputTupleType, Type as InputType,
 };

 use serde::{Deserialize, Serialize};
--- a/compiler/Cargo.toml
+++ b/compiler/Cargo.toml
@ -61,28 +61,28 @@ version = "1.5.3"
 version = "0.4"

 [dependencies.snarkvm-curves]
-version = "0.7.5"
+version = "0.7.7"
 default-features = false

 [dependencies.snarkvm-fields]
-version = "0.7.5"
+version = "0.7.7"
 default-features = false

 [dependencies.snarkvm-dpc]
-version = "0.7.5"
+version = "0.7.7"
 default-features = false

 [dependencies.snarkvm-gadgets]
-version = "0.7.5"
+version = "0.7.7"
 default-features = false
 features = [ "curves" ]

 [dependencies.snarkvm-r1cs]
-version = "0.7.5"
+version = "0.7.7"
 default-features = false

 [dependencies.snarkvm-utilities]
-version = "0.7.4"
+version = "0.7.6"

 [dependencies.bincode]
 version = "1.3"
@ -120,7 +120,7 @@ version = "0.3"
 default-features = false

 [dev-dependencies.snarkvm-algorithms]
-version = "0.7.4"
+version = "0.7.6"
 default-features = false

 [dev-dependencies.tempfile]
--- a/compiler/src/compiler.rs
+++ b/compiler/src/compiler.rs
@ -17,12 +17,7 @@
 //! Compiles a Leo program from a file path.
 use crate::{
    constraints::{generate_constraints, generate_test_constraints},
-    AstSnapshotOptions,
-    CompilerOptions,
-    GroupType,
-    Output,
-    OutputFile,
-    TypeInferencePhase,
+    AstSnapshotOptions, CompilerOptions, GroupType, Output, OutputFile, TypeInferencePhase,
 };
 pub use leo_asg::{new_context, AsgContext as Context, AsgContext};
 use leo_asg::{Asg, AsgPass, Program as AsgProgram};
--- a/compiler/src/errors/expression.rs
+++ b/compiler/src/errors/expression.rs
@ -0,0 +1,167 @@
+// Copyright (C) 2019-2021 Aleo Systems Inc.
+// This file is part of the Leo library.
+
+// The Leo library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The Leo library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
+
+use crate::errors::{
+    AddressError, BooleanError, CharError, FieldError, FunctionError, GroupError, IntegerError, ValueError,
+};
+use leo_ast::{FormattedError, Identifier, LeoError, Span};
+use snarkvm_r1cs::SynthesisError;
+
+#[derive(Debug, Error)]
+pub enum ExpressionError {
+    #[error("{}", _0)]
+    AddressError(#[from] AddressError),
+
+    #[error("{}", _0)]
+    BooleanError(#[from] BooleanError),
+
+    #[error("{}", _0)]
+    CharError(#[from] CharError),
+
+    #[error("{}", _0)]
+    Error(#[from] FormattedError),
+
+    #[error("{}", _0)]
+    FieldError(#[from] FieldError),
+
+    #[error("{}", _0)]
+    FunctionError(#[from] Box<FunctionError>),
+
+    #[error("{}", _0)]
+    GroupError(#[from] GroupError),
+
+    #[error("{}", _0)]
+    IntegerError(#[from] IntegerError),
+
+    #[error("{}", _0)]
+    ValueError(#[from] ValueError),
+}
+
+impl LeoError for ExpressionError {}
+
+impl ExpressionError {
+    fn new_from_span(message: String, span: &Span) -> Self {
+        ExpressionError::Error(FormattedError::new_from_span(message, span))
+    }
+
+    pub fn cannot_enforce(operation: String, error: SynthesisError, span: &Span) -> Self {
+        let message = format!(
+            "the gadget operation `{}` failed due to synthesis error `{:?}`",
+            operation, error,
+        );
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn cannot_evaluate(operation: String, span: &Span) -> Self {
+        let message = format!("Mismatched types found for operation `{}`", operation);
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn array_length_out_of_bounds(span: &Span) -> Self {
+        let message = "array length cannot be >= 2^32".to_string();
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn array_index_out_of_legal_bounds(span: &Span) -> Self {
+        let message = "array index cannot be >= 2^32".to_string();
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn conditional_boolean(actual: String, span: &Span) -> Self {
+        let message = format!("if, else conditional must resolve to a boolean, found `{}`", actual);
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn expected_circuit_member(expected: String, span: &Span) -> Self {
+        let message = format!("expected circuit member `{}`, not found", expected);
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn incompatible_types(operation: String, span: &Span) -> Self {
+        let message = format!("no implementation for `{}`", operation);
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn tuple_index_out_of_bounds(index: usize, span: &Span) -> Self {
+        let message = format!("cannot access index {} of tuple out of bounds", index);
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn array_index_out_of_bounds(index: usize, span: &Span) -> Self {
+        let message = format!("cannot access index {} of array out of bounds", index);
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn array_invalid_slice_length(span: &Span) -> Self {
+        let message = "illegal length of slice".to_string();
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn invalid_index(actual: String, span: &Span) -> Self {
+        let message = format!("index must resolve to an integer, found `{}`", actual);
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn invalid_length(expected: usize, actual: usize, span: &Span) -> Self {
+        let message = format!("expected array length {}, found one with length {}", expected, actual);
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn invalid_static_access(member: String, span: &Span) -> Self {
+        let message = format!("static member `{}` must be accessed using `::` syntax", member);
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn undefined_array(actual: String, span: &Span) -> Self {
+        let message = format!("array `{}` must be declared before it is used in an expression", actual);
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn undefined_circuit(actual: String, span: &Span) -> Self {
+        let message = format!(
+            "circuit `{}` must be declared before it is used in an expression",
+            actual
+        );
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn undefined_identifier(identifier: Identifier) -> Self {
+        let message = format!("Cannot find value `{}` in this scope", identifier.name);
+
+        Self::new_from_span(message, &identifier.span)
+    }
+
+    pub fn undefined_member_access(circuit: String, member: String, span: &Span) -> Self {
+        let message = format!("Circuit `{}` has no member `{}`", circuit, member);
+
+        Self::new_from_span(message, span)
+    }
+}
--- a/compiler/src/errors/function.rs
+++ b/compiler/src/errors/function.rs
@ -0,0 +1,138 @@
+// Copyright (C) 2019-2021 Aleo Systems Inc.
+// This file is part of the Leo library.
+
+// The Leo library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The Leo library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
+
+use crate::errors::{
+    AddressError, BooleanError, CharError, ExpressionError, FieldError, GroupError, IntegerError, OutputBytesError,
+    StatementError, ValueError,
+};
+use leo_asg::AsgConvertError;
+use leo_ast::{FormattedError, LeoError, Span};
+
+#[derive(Debug, Error)]
+pub enum FunctionError {
+    #[error("{}", _0)]
+    AddressError(#[from] AddressError),
+
+    #[error("{}", _0)]
+    BooleanError(#[from] BooleanError),
+
+    #[error("{}", _0)]
+    CharError(#[from] CharError),
+
+    #[error("{}", _0)]
+    ExpressionError(#[from] ExpressionError),
+
+    #[error("{}", _0)]
+    Error(#[from] FormattedError),
+
+    #[error("{}", _0)]
+    FieldError(#[from] FieldError),
+
+    #[error("{}", _0)]
+    GroupError(#[from] GroupError),
+
+    #[error("{}", _0)]
+    IntegerError(#[from] IntegerError),
+
+    #[error("{}", _0)]
+    OutputStringError(#[from] OutputBytesError),
+
+    #[error("{}", _0)]
+    StatementError(#[from] StatementError),
+
+    #[error("{}", _0)]
+    ValueError(#[from] ValueError),
+
+    #[error("{}", _0)]
+    ImportASGError(#[from] AsgConvertError),
+}
+
+impl LeoError for FunctionError {}
+
+impl FunctionError {
+    fn new_from_span(message: String, span: &Span) -> Self {
+        FunctionError::Error(FormattedError::new_from_span(message, span))
+    }
+
+    pub fn input_type_mismatch(expected: String, actual: String, variable: String, span: &Span) -> Self {
+        let message = format!(
+            "Expected input variable `{}` to be type `{}`, found type `{}`",
+            variable, expected, actual
+        );
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn expected_const_input(variable: String, span: &Span) -> Self {
+        let message = format!(
+            "Expected input variable `{}` to be constant. Move input variable `{}` to [constants] section of input file",
+            variable, variable
+        );
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn expected_non_const_input(variable: String, span: &Span) -> Self {
+        let message = format!(
+            "Expected input variable `{}` to be non-constant. Move input variable `{}` to [main] section of input file",
+            variable, variable
+        );
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn invalid_array(actual: String, span: &Span) -> Self {
+        let message = format!("Expected function input array, found `{}`", actual);
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn invalid_input_array_dimensions(expected: usize, actual: usize, span: &Span) -> Self {
+        let message = format!(
+            "Input array dimensions mismatch expected {}, found array dimensions {}",
+            expected, actual
+        );
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn tuple_size_mismatch(expected: usize, actual: usize, span: &Span) -> Self {
+        let message = format!(
+            "Input tuple size mismatch expected {}, found tuple with length {}",
+            expected, actual
+        );
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn invalid_tuple(actual: String, span: &Span) -> Self {
+        let message = format!("Expected function input tuple, found `{}`", actual);
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn input_not_found(expected: String, span: &Span) -> Self {
+        let message = format!("main function input {} not found", expected);
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn double_input_declaration(input_name: String, span: &Span) -> Self {
+        let message = format!("Input variable {} declared twice", input_name);
+
+        Self::new_from_span(message, span)
+    }
+}
--- a/compiler/src/expression/expression.rs
+++ b/compiler/src/expression/expression.rs
@ -23,8 +23,7 @@ use crate::{
    relational::*,
    resolve_core_circuit,
    value::{Address, Char, CharType, ConstrainedCircuitMember, ConstrainedValue, Integer},
-    FieldType,
-    GroupType,
+    FieldType, GroupType,
 };
 use leo_asg::{expression::*, ConstValue, Expression, Node};
 use leo_errors::{Result, Span};
--- a/compiler/src/function/input/main_function_input.rs
+++ b/compiler/src/function/input/main_function_input.rs
@ -20,16 +20,10 @@ use crate::{
    address::Address,
    program::ConstrainedProgram,
    value::{
-        boolean::input::bool_from_input,
-        char::char_from_input,
-        field::input::field_from_input,
-        group::input::group_from_input,
-        ConstrainedValue,
+        boolean::input::bool_from_input, char::char_from_input, field::input::field_from_input,
+        group::input::group_from_input, ConstrainedValue,
    },
-    CharType,
-    FieldType,
-    GroupType,
-    Integer,
+    CharType, FieldType, GroupType, Integer,
 };
 use leo_asg::{ConstInt, Type};
 use leo_ast::{Char, InputValue};
@ -100,9 +94,7 @@ impl<'a, F: PrimeField, G: GroupType<F>> ConstrainedProgram<'a, F, G> {
            (Type::Field, InputValue::Field(value)) => {
                Ok(ConstrainedValue::Field(FieldType::constant(cs, value, span)?))
            }
-            (Type::Group, InputValue::Group(value)) => {
-                Ok(ConstrainedValue::Group(G::constant(&(*value).into(), span)?))
-            }
+            (Type::Group, InputValue::Group(value)) => Ok(ConstrainedValue::Group(G::constant(&value.into(), span)?)),
            (Type::Integer(integer_type), InputValue::Integer(input_type, value)) => {
                let parsed = ConstInt::parse(integer_type, &value, span)?;
                let parsed_type = parsed.get_int_type();
--- a/compiler/src/function/mut_target.rs
+++ b/compiler/src/function/mut_target.rs
@ -20,16 +20,8 @@ use std::cell::Cell;

 use crate::{program::ConstrainedProgram, value::ConstrainedValue, GroupType};
 use leo_asg::{
-    ArrayAccessExpression,
-    ArrayRangeAccessExpression,
-    AssignAccess,
-    AssignOperation,
-    AssignStatement,
-    CircuitAccessExpression,
-    Expression,
-    Node,
-    TupleAccessExpression,
-    Variable,
+    ArrayAccessExpression, ArrayRangeAccessExpression, AssignAccess, AssignOperation, AssignStatement,
+    CircuitAccessExpression, Expression, Node, TupleAccessExpression, Variable,
 };
 use leo_errors::Result;

--- a/compiler/src/output/mod.rs
+++ b/compiler/src/output/mod.rs
@ -155,10 +155,13 @@ impl Output {
                _ => value.to_string(),
            };

-            registers.insert(name.to_string(), OutputRegister {
+            registers.insert(
+                name.to_string(),
+                OutputRegister {
                    type_: register_type.to_string(),
                    value,
-            });
+                },
+            );
        }

        Ok(Output { registers })
--- a/compiler/src/output/output_file.rs
+++ b/compiler/src/output/output_file.rs
@ -21,8 +21,7 @@ use leo_errors::{CompilerError, Result};
 use std::{
    borrow::Cow,
    fs::{
-        File,
-        {self},
+        File, {self},
    },
    io::Write,
    path::Path,
--- a/compiler/src/phases/reducing_director.rs
+++ b/compiler/src/phases/reducing_director.rs
@ -18,83 +18,37 @@

 use indexmap::IndexMap;
 use leo_asg::{
-    ArrayAccessExpression as AsgArrayAccessExpression,
-    ArrayInitExpression as AsgArrayInitExpression,
-    ArrayInlineExpression as AsgArrayInlineExpression,
-    ArrayRangeAccessExpression as AsgArrayRangeAccessExpression,
-    AssignAccess as AsgAssignAccess,
-    AssignStatement as AsgAssignStatement,
-    BinaryExpression as AsgBinaryExpression,
-    BlockStatement as AsgBlockStatement,
-    CallExpression as AsgCallExpression,
-    CastExpression as AsgCastExpression,
-    CharValue as AsgCharValue,
-    Circuit as AsgCircuit,
-    CircuitAccessExpression as AsgCircuitAccessExpression,
-    CircuitInitExpression as AsgCircuitInitExpression,
-    CircuitMember as AsgCircuitMember,
-    ConditionalStatement as AsgConditionalStatement,
-    ConsoleFunction as AsgConsoleFunction,
-    ConsoleStatement as AsgConsoleStatement,
-    ConstValue,
-    Constant as AsgConstant,
-    DefinitionStatement as AsgDefinitionStatement,
-    Expression as AsgExpression,
-    ExpressionStatement as AsgExpressionStatement,
-    Function as AsgFunction,
-    GroupValue as AsgGroupValue,
-    IterationStatement as AsgIterationStatement,
-    ReturnStatement as AsgReturnStatement,
-    Statement as AsgStatement,
-    TernaryExpression as AsgTernaryExpression,
-    TupleAccessExpression as AsgTupleAccessExpression,
-    TupleInitExpression as AsgTupleInitExpression,
-    Type as AsgType,
-    UnaryExpression as AsgUnaryExpression,
+    ArrayAccessExpression as AsgArrayAccessExpression, ArrayInitExpression as AsgArrayInitExpression,
+    ArrayInlineExpression as AsgArrayInlineExpression, ArrayRangeAccessExpression as AsgArrayRangeAccessExpression,
+    AssignAccess as AsgAssignAccess, AssignStatement as AsgAssignStatement, BinaryExpression as AsgBinaryExpression,
+    BlockStatement as AsgBlockStatement, CallExpression as AsgCallExpression, CastExpression as AsgCastExpression,
+    CharValue as AsgCharValue, Circuit as AsgCircuit, CircuitAccessExpression as AsgCircuitAccessExpression,
+    CircuitInitExpression as AsgCircuitInitExpression, CircuitMember as AsgCircuitMember,
+    ConditionalStatement as AsgConditionalStatement, ConsoleFunction as AsgConsoleFunction,
+    ConsoleStatement as AsgConsoleStatement, ConstValue, Constant as AsgConstant,
+    DefinitionStatement as AsgDefinitionStatement, Expression as AsgExpression,
+    ExpressionStatement as AsgExpressionStatement, Function as AsgFunction, GroupValue as AsgGroupValue,
+    IterationStatement as AsgIterationStatement, ReturnStatement as AsgReturnStatement, Statement as AsgStatement,
+    TernaryExpression as AsgTernaryExpression, TupleAccessExpression as AsgTupleAccessExpression,
+    TupleInitExpression as AsgTupleInitExpression, Type as AsgType, UnaryExpression as AsgUnaryExpression,
    VariableRef as AsgVariableRef,
 };
 use leo_ast::{
-    ArrayAccessExpression as AstArrayAccessExpression,
-    ArrayDimensions,
-    ArrayInitExpression as AstArrayInitExpression,
-    ArrayInlineExpression as AstArrayInlineExpression,
-    ArrayRangeAccessExpression as AstArrayRangeAccessExpression,
-    AssignStatement as AstAssignStatement,
-    Assignee,
-    AssigneeAccess as AstAssignAccess,
-    BinaryExpression as AstBinaryExpression,
-    Block as AstBlockStatement,
-    CallExpression as AstCallExpression,
-    CastExpression as AstCastExpression,
-    Char,
-    CharValue as AstCharValue,
-    Circuit as AstCircuit,
-    CircuitImpliedVariableDefinition,
-    CircuitInitExpression as AstCircuitInitExpression,
-    CircuitMember as AstCircuitMember,
-    CircuitMemberAccessExpression,
-    CircuitStaticFunctionAccessExpression,
-    ConditionalStatement as AstConditionalStatement,
-    ConsoleArgs as AstConsoleArgs,
-    ConsoleFunction as AstConsoleFunction,
-    ConsoleStatement as AstConsoleStatement,
-    DefinitionStatement as AstDefinitionStatement,
-    Expression as AstExpression,
-    ExpressionStatement as AstExpressionStatement,
-    Function as AstFunction,
-    GroupTuple,
-    GroupValue as AstGroupValue,
-    IterationStatement as AstIterationStatement,
-    PositiveNumber,
-    ReconstructingReducer,
-    ReturnStatement as AstReturnStatement,
-    SpreadOrExpression,
-    Statement as AstStatement,
-    TernaryExpression as AstTernaryExpression,
-    TupleAccessExpression as AstTupleAccessExpression,
-    TupleInitExpression as AstTupleInitExpression,
-    Type as AstType,
-    UnaryExpression as AstUnaryExpression,
+    ArrayAccessExpression as AstArrayAccessExpression, ArrayDimensions, ArrayInitExpression as AstArrayInitExpression,
+    ArrayInlineExpression as AstArrayInlineExpression, ArrayRangeAccessExpression as AstArrayRangeAccessExpression,
+    AssignStatement as AstAssignStatement, Assignee, AssigneeAccess as AstAssignAccess,
+    BinaryExpression as AstBinaryExpression, Block as AstBlockStatement, CallExpression as AstCallExpression,
+    CastExpression as AstCastExpression, Char, CharValue as AstCharValue, Circuit as AstCircuit,
+    CircuitImpliedVariableDefinition, CircuitInitExpression as AstCircuitInitExpression,
+    CircuitMember as AstCircuitMember, CircuitMemberAccessExpression, CircuitStaticFunctionAccessExpression,
+    ConditionalStatement as AstConditionalStatement, ConsoleArgs as AstConsoleArgs,
+    ConsoleFunction as AstConsoleFunction, ConsoleStatement as AstConsoleStatement,
+    DefinitionStatement as AstDefinitionStatement, Expression as AstExpression,
+    ExpressionStatement as AstExpressionStatement, Function as AstFunction, GroupTuple, GroupValue as AstGroupValue,
+    IterationStatement as AstIterationStatement, PositiveNumber, ReconstructingReducer,
+    ReturnStatement as AstReturnStatement, SpreadOrExpression, Statement as AstStatement,
+    TernaryExpression as AstTernaryExpression, TupleAccessExpression as AstTupleAccessExpression,
+    TupleInitExpression as AstTupleInitExpression, Type as AstType, UnaryExpression as AstUnaryExpression,
    ValueExpression,
 };
 use leo_errors::{AstError, Result, Span};
@ -399,11 +353,11 @@ impl<R: ReconstructingReducer, O: CombinerOptions> CombineAstAsgDirector<R, O> {
                    ConstValue::Group(group) => {
                        let group_value = match group {
                            AsgGroupValue::Single(_) => AstGroupValue::Single(tendril.clone(), span.clone()),
-                            AsgGroupValue::Tuple(x, y) => AstGroupValue::Tuple(Box::new(GroupTuple {
+                            AsgGroupValue::Tuple(x, y) => AstGroupValue::Tuple(GroupTuple {
                                x: x.into(),
                                y: y.into(),
                                span: span.clone(),
-                            })),
+                            }),
                        };
                        new = ValueExpression::Group(Box::new(group_value));
                    }
@ -732,7 +686,7 @@ impl<R: ReconstructingReducer, O: CombinerOptions> CombineAstAsgDirector<R, O> {
                )
            }
            (AstCircuitMember::CircuitFunction(ast_function), AsgCircuitMember::Function(asg_function)) => {
-                AstCircuitMember::CircuitFunction(Box::new(self.reduce_function(ast_function, asg_function)?))
+                AstCircuitMember::CircuitFunction(self.reduce_function(ast_function, asg_function)?)
            }
            _ => ast.clone(),
        };
--- a/compiler/src/prelude/blake2s.rs
+++ b/compiler/src/prelude/blake2s.rs
@ -21,10 +21,7 @@ use leo_errors::{CompilerError, Result, Span};

 use snarkvm_fields::PrimeField;
 use snarkvm_gadgets::{
-    algorithms::prf::Blake2sGadget,
-    bits::ToBytesGadget,
-    integers::uint::UInt8,
-    traits::algorithms::PRFGadget,
+    algorithms::prf::Blake2sGadget, bits::ToBytesGadget, integers::uint::UInt8, traits::algorithms::PRFGadget,
 };
 use snarkvm_r1cs::ConstraintSystem;

--- a/compiler/src/statement/assign/assignee/mod.rs
+++ b/compiler/src/statement/assign/assignee/mod.rs
@ -96,7 +96,9 @@ impl<'a, F: PrimeField, G: GroupType<F>> ConstrainedProgram<'a, F, G> {

        let mut target = self.get(variable.id).unwrap().clone();
        let accesses: Vec<_> = assignee.target_accesses.iter().rev().collect();
-        self.resolve_target_access(cs, ResolverContext {
+        self.resolve_target_access(
+            cs,
+            ResolverContext {
                input: vec![&mut target],
                span,
                target_value,
@ -104,7 +106,8 @@ impl<'a, F: PrimeField, G: GroupType<F>> ConstrainedProgram<'a, F, G> {
                indicator,
                operation: assignee.operation,
                from_range: false,
-        })?;
+            },
+        )?;
        *self.get_mut(variable.id).unwrap() = target;
        Ok(())
    }
--- a/compiler/src/statement/conditional/conditional.rs
+++ b/compiler/src/statement/conditional/conditional.rs
@ -17,11 +17,7 @@
 //! Methods to enforce constraints on statements in a compiled Leo program.

 use crate::{
-    program::ConstrainedProgram,
-    value::ConstrainedValue,
-    GroupType,
-    IndicatorAndConstrainedValue,
-    StatementResult,
+    program::ConstrainedProgram, value::ConstrainedValue, GroupType, IndicatorAndConstrainedValue, StatementResult,
 };
 use leo_asg::ConditionalStatement;
 use leo_errors::CompilerError;
--- a/compiler/src/statement/iteration/iteration.rs
+++ b/compiler/src/statement/iteration/iteration.rs
@ -17,13 +17,8 @@
 //! Enforces an iteration statement in a compiled Leo program.

 use crate::{
-    program::ConstrainedProgram,
-    value::ConstrainedValue,
-    GroupType,
-    IndicatorAndConstrainedValue,
-    Integer,
-    IntegerTrait,
-    StatementResult,
+    program::ConstrainedProgram, value::ConstrainedValue, GroupType, IndicatorAndConstrainedValue, Integer,
+    IntegerTrait, StatementResult,
 };
 use leo_asg::IterationStatement;
 use leo_errors::CompilerError;
--- a/compiler/src/value/address/address.rs
+++ b/compiler/src/value/address/address.rs
@ -226,7 +226,11 @@ impl<F: PrimeField> ConditionalEqGadget<F> for Address {
 }

 fn cond_select_helper(first: &Address, second: &Address, cond: bool) -> Address {
-    if cond { first.clone() } else { second.clone() }
+    if cond {
+        first.clone()
+    } else {
+        second.clone()
+    }
 }

 impl<F: PrimeField> CondSelectGadget<F> for Address {
--- a/compiler/src/value/char/char.rs
+++ b/compiler/src/value/char/char.rs
@ -16,8 +16,7 @@

 use crate::{
    value::{field::input::allocate_field, ConstrainedValue},
-    FieldType,
-    GroupType,
+    FieldType, GroupType,
 };

 use leo_ast::InputValue;
--- a/compiler/src/value/group/input.rs
+++ b/compiler/src/value/group/input.rs
@ -58,9 +58,9 @@ pub(crate) fn group_from_input<'a, F: PrimeField, G: GroupType<F>, CS: Constrain
    let group = allocate_group(
        cs,
        name,
-        option.map(|x| match *x {
+        option.map(|x| match x {
            leo_ast::GroupValue::Single(s, _) => GroupValue::Single(s),
-            leo_ast::GroupValue::Tuple(tuple) => GroupValue::Tuple((&tuple.x).into(), (&tuple.y).into()),
+            leo_ast::GroupValue::Tuple(leo_ast::GroupTuple { x, y, .. }) => GroupValue::Tuple((&x).into(), (&y).into()),
        }),
        span,
    )?;
--- a/compiler/src/value/group/targets/edwards_bls12.rs
+++ b/compiler/src/value/group/targets/edwards_bls12.rs
@ -21,8 +21,7 @@ use leo_errors::{CompilerError, Result, Span};
 use snarkvm_curves::{
    edwards_bls12::{EdwardsAffine, EdwardsParameters, Fq},
    templates::twisted_edwards_extended::Affine,
-    AffineCurve,
-    TwistedEdwardsParameters,
+    AffineCurve, TwistedEdwardsParameters,
 };
 use snarkvm_fields::{Fp256, One, Zero};
 use snarkvm_gadgets::{
@ -485,7 +484,11 @@ impl CondSelectGadget<Fq> for EdwardsGroupType {
        second: &Self,
    ) -> Result<Self, SynthesisError> {
        if let Boolean::Constant(cond) = *cond {
-            if cond { Ok(first.clone()) } else { Ok(second.clone()) }
+            if cond {
+                Ok(first.clone())
+            } else {
+                Ok(second.clone())
+            }
        } else {
            let first_gadget = first.allocated(cs.ns(|| "first"))?;
            let second_gadget = second.allocated(cs.ns(|| "second"))?;
--- a/errors/Cargo.toml
+++ b/errors/Cargo.toml
@ -17,13 +17,13 @@ include = [ "Cargo.toml", "src", "README.md", "LICENSE.md" ]
 license = "GPL-3.0"
 edition = "2018"

-[dependencies]
-color-backtrace = "0.5.1"
-
 [dependencies.leo-input]
 path = "../input"
 version = "1.5.3"

+[dependencies.color-backtrace]
+version = "0.5.1"
+
 [dependencies.derivative]
 version = "2.2.0"

--- a/errors/src/cli/cli_errors.rs
+++ b/errors/src/cli/cli_errors.rs
@ -25,6 +25,13 @@ create_errors!(
    exit_code_mask: 7000i32,
    error_code_prefix: "CLI",

+    @backtraced
+    opt_args_error {
+        args: (error: impl ErrorArg),
+        msg: format!("opt arg error {}", error),
+        help: None,
+    }
+
    @backtraced
    unidentified_api {
        args: (),
--- a/errors/src/common/backtraced.rs
+++ b/errors/src/common/backtraced.rs
@ -101,7 +101,6 @@ impl fmt::Display for BacktracedError {
        let leo_backtrace = std::env::var("LEO_BACKTRACE").unwrap_or_default().trim().to_owned();
        match leo_backtrace.as_ref() {
            "1" => {
-                dbg!("1");
                let mut printer = BacktracePrinter::default();
                printer = printer.lib_verbosity(Verbosity::Medium);
                let trace = printer
@ -110,7 +109,6 @@ impl fmt::Display for BacktracedError {
                write!(f, "{}", trace)?;
            }
            "full" => {
-                dbg!("full");
                let mut printer = BacktracePrinter::default();
                printer = printer.lib_verbosity(Verbosity::Full);
                let trace = printer
--- a/grammar/README.md
+++ b/grammar/README.md
@ -476,7 +476,7 @@ Line terminators form whitespace, along with spaces and horizontal tabs.
 whitespace = space / horizontal-tab / newline
 ```

-Go to: _[space](#user-content-space), [newline](#user-content-newline), [horizontal-tab](#user-content-horizontal-tab)_;
+Go to: _[horizontal-tab](#user-content-horizontal-tab), [newline](#user-content-newline), [space](#user-content-space)_;


 There are two kinds of comments in Leo, as in other languages.
@ -511,7 +511,7 @@ rest-of-block-comment = "*" rest-of-block-comment-after-star
                      / not-star rest-of-block-comment
 ```

-Go to: _[not-star](#user-content-not-star), [rest-of-block-comment](#user-content-rest-of-block-comment), [rest-of-block-comment-after-star](#user-content-rest-of-block-comment-after-star)_;
+Go to: _[rest-of-block-comment-after-star](#user-content-rest-of-block-comment-after-star), [not-star](#user-content-not-star), [rest-of-block-comment](#user-content-rest-of-block-comment)_;


 <a name="rest-of-block-comment-after-star"></a>
@ -521,7 +521,7 @@ rest-of-block-comment-after-star = "/"
                                 / not-star-or-slash rest-of-block-comment
 ```

-Go to: _[rest-of-block-comment-after-star](#user-content-rest-of-block-comment-after-star), [not-star-or-slash](#user-content-not-star-or-slash), [rest-of-block-comment](#user-content-rest-of-block-comment)_;
+Go to: _[not-star-or-slash](#user-content-not-star-or-slash), [rest-of-block-comment](#user-content-rest-of-block-comment), [rest-of-block-comment-after-star](#user-content-rest-of-block-comment-after-star)_;


 <a name="end-of-line-comment"></a>
@ -572,13 +572,7 @@ keyword = %s"address"
        / %s"u128"
 ```

-The following rules define (ASCII)
-digits and (uppercase and lowercase) letters.
-
-<a name="digit"></a>
-```abnf
-digit = %x30-39   ; 0-9
-```
+The following rules define (ASCII) letters.

 <a name="uppercase-letter"></a>
 ```abnf
@ -595,12 +589,17 @@ lowercase-letter = %x61-7A   ; a-z
 letter = uppercase-letter / lowercase-letter
 ```

-Go to: _[lowercase-letter](#user-content-lowercase-letter), [uppercase-letter](#user-content-uppercase-letter)_;
+Go to: _[uppercase-letter](#user-content-uppercase-letter), [lowercase-letter](#user-content-lowercase-letter)_;


-The following rules defines (ASCII) octal and hexadecimal digits.
+The following rules defines (ASCII) decimal, octal, and hexadecimal digits.
 Note that the latter are case-insensitive.

+<a name="decimal-digit"></a>
+```abnf
+decimal-digit = %x30-39   ; 0-9
+```
+
 <a name="octal-digit"></a>
 ```abnf
 octal-digit = %x30-37   ; 0-7
@ -608,13 +607,14 @@ octal-digit = %x30-37   ; 0-7

 <a name="hexadecimal-digit"></a>
 ```abnf
-hexadecimal-digit = digit / "a" / "b" / "c" / "d" / "e" / "f"
+hexadecimal-digit = decimal-digit / "a" / "b" / "c" / "d" / "e" / "f"
 ```

-Go to: _[digit](#user-content-digit)_;
+Go to: _[decimal-digit](#user-content-decimal-digit)_;


-An identifier is a non-empty sequence of letters, digits, and underscores,
+An identifier is a non-empty sequence of
+letters, (decimal) digits, and underscores,
 starting with a letter.
 It must not be a keyword: this is an extra-grammatical requirement.
 It must also not be or start with `aleo1`,
@ -623,7 +623,7 @@ this is another extra-grammatical requirement.

 <a name="identifier"></a>
 ```abnf
-identifier = letter *( letter / digit / "_" )
+identifier = letter *( letter / decimal-digit / "_" )
             ; but not a keyword or a boolean literal or aleo1...
 ```

@ -631,14 +631,15 @@ Go to: _[letter](#user-content-letter)_;


 A package name consists of one or more segments separated by single dashes,
-where each segment is a non-empty sequence of lowercase letters and digits.
+where each segment is a non-empty sequence of
+lowercase letters and (decimal) digits.
 Similarly to an identifier, a package name must not be a keyword
 and must not be or start with `aleo1`.

 <a name="package-name"></a>
 ```abnf
-package-name = lowercase-letter *( lowercase-letter / digit )
-               *( "-" 1*( lowercase-letter / digit ) )
+package-name = lowercase-letter *( lowercase-letter / decimal-digit )
+               *( "-" 1*( lowercase-letter / decimal-digit ) )
               ; but not a keyword or a boolean literal or aleo1...
 ```

@ -658,12 +659,12 @@ annotation-name = "@" identifier
 Go to: _[identifier](#user-content-identifier)_;


-A natural (number) is a sequence of one or more digits.
+A natural (number) is a sequence of one or more decimal digits.
 We allow leading zeros, e.g. `007`.

 <a name="natural"></a>
 ```abnf
-natural = 1*digit
+natural = 1*decimal-digit
 ```

 An integer (number) is either a natural or its negation.
@ -739,12 +740,12 @@ boolean-literal = %s"true" / %s"false"
 ```

 An address literal starts with `aleo1`
-and continues with exactly 58 lowercase letters and digits.
+and continues with exactly 58 lowercase letters and (decimal) digits.
 Thus an address always consists of 63 characters.

 <a name="address-literal"></a>
 ```abnf
-address-literal = %s"aleo1" 58( lowercase-letter / digit )
+address-literal = %s"aleo1" 58( lowercase-letter / decimal-digit )
 ```

 A character literal consists of an element surrounded by single quotes.
@ -772,7 +773,7 @@ character-literal-element = not-single-quote-or-backslash
                          / unicode-character-escape
 ```

-Go to: _[unicode-character-escape](#user-content-unicode-character-escape), [simple-character-escape](#user-content-simple-character-escape), [not-single-quote-or-backslash](#user-content-not-single-quote-or-backslash), [ascii-character-escape](#user-content-ascii-character-escape)_;
+Go to: _[not-single-quote-or-backslash](#user-content-not-single-quote-or-backslash), [ascii-character-escape](#user-content-ascii-character-escape), [unicode-character-escape](#user-content-unicode-character-escape), [simple-character-escape](#user-content-simple-character-escape)_;


 <a name="single-quote-escape"></a>
@ -827,7 +828,7 @@ simple-character-escape = single-quote-escape
                        / null-character-escape
 ```

-Go to: _[horizontal-tab-escape](#user-content-horizontal-tab-escape), [backslash-escape](#user-content-backslash-escape), [null-character-escape](#user-content-null-character-escape), [line-feed-escape](#user-content-line-feed-escape), [single-quote-escape](#user-content-single-quote-escape), [double-quote-escape](#user-content-double-quote-escape), [carriage-return-escape](#user-content-carriage-return-escape)_;
+Go to: _[carriage-return-escape](#user-content-carriage-return-escape), [horizontal-tab-escape](#user-content-horizontal-tab-escape), [null-character-escape](#user-content-null-character-escape), [double-quote-escape](#user-content-double-quote-escape), [single-quote-escape](#user-content-single-quote-escape), [backslash-escape](#user-content-backslash-escape), [line-feed-escape](#user-content-line-feed-escape)_;


 <a name="ascii-character-escape"></a>
@ -863,7 +864,7 @@ string-literal-element = not-double-quote-or-backslash
                       / unicode-character-escape
 ```

-Go to: _[not-double-quote-or-backslash](#user-content-not-double-quote-or-backslash), [simple-character-escape](#user-content-simple-character-escape), [ascii-character-escape](#user-content-ascii-character-escape), [unicode-character-escape](#user-content-unicode-character-escape)_;
+Go to: _[ascii-character-escape](#user-content-ascii-character-escape), [unicode-character-escape](#user-content-unicode-character-escape), [simple-character-escape](#user-content-simple-character-escape), [not-double-quote-or-backslash](#user-content-not-double-quote-or-backslash)_;


 The ones above are all the atomic literals
@ -883,7 +884,7 @@ atomic-literal = untyped-literal
               / string-literal
 ```

-Go to: _[signed-literal](#user-content-signed-literal), [unsigned-literal](#user-content-unsigned-literal), [field-literal](#user-content-field-literal), [product-group-literal](#user-content-product-group-literal), [boolean-literal](#user-content-boolean-literal), [address-literal](#user-content-address-literal), [string-literal](#user-content-string-literal), [untyped-literal](#user-content-untyped-literal), [character-literal](#user-content-character-literal)_;
+Go to: _[signed-literal](#user-content-signed-literal), [untyped-literal](#user-content-untyped-literal), [product-group-literal](#user-content-product-group-literal), [unsigned-literal](#user-content-unsigned-literal), [character-literal](#user-content-character-literal), [string-literal](#user-content-string-literal), [field-literal](#user-content-field-literal), [boolean-literal](#user-content-boolean-literal), [address-literal](#user-content-address-literal)_;


 After defining the (mostly) alphanumeric tokens above,
@ -927,7 +928,7 @@ token = keyword
      / symbol
 ```

-Go to: _[atomic-literal](#user-content-atomic-literal), [package-name](#user-content-package-name), [annotation-name](#user-content-annotation-name), [symbol](#user-content-symbol), [identifier](#user-content-identifier), [keyword](#user-content-keyword)_;
+Go to: _[identifier](#user-content-identifier), [keyword](#user-content-keyword), [symbol](#user-content-symbol), [package-name](#user-content-package-name), [annotation-name](#user-content-annotation-name), [atomic-literal](#user-content-atomic-literal)_;


 Tokens, comments, and whitespace are lexemes, i.e. lexical units.
@ -937,7 +938,7 @@ Tokens, comments, and whitespace are lexemes, i.e. lexical units.
 lexeme = token / comment / whitespace
 ```

-Go to: _[whitespace](#user-content-whitespace), [comment](#user-content-comment), [token](#user-content-token)_;
+Go to: _[whitespace](#user-content-whitespace), [token](#user-content-token), [comment](#user-content-comment)_;



@ -973,7 +974,7 @@ signed-type = %s"i8" / %s"i16" / %s"i32" / %s"i64" / %s"i128"
 integer-type = unsigned-type / signed-type
 ```

-Go to: _[unsigned-type](#user-content-unsigned-type), [signed-type](#user-content-signed-type)_;
+Go to: _[signed-type](#user-content-signed-type), [unsigned-type](#user-content-unsigned-type)_;


 The integer types, along with the field and group types,
@ -1020,7 +1021,7 @@ character-type = %s"char"
 scalar-type =  boolean-type / arithmetic-type / address-type / character-type
 ```

-Go to: _[address-type](#user-content-address-type), [boolean-type](#user-content-boolean-type), [character-type](#user-content-character-type), [arithmetic-type](#user-content-arithmetic-type)_;
+Go to: _[character-type](#user-content-character-type), [arithmetic-type](#user-content-arithmetic-type), [boolean-type](#user-content-boolean-type), [address-type](#user-content-address-type)_;


 Circuit types are denoted by identifiers and the keyword `Self`.
@ -1060,7 +1061,7 @@ or a tuple of one or more dimensions.
 array-type = "[" type ";" array-dimensions "]"
 ```

-Go to: _[type](#user-content-type), [array-dimensions](#user-content-array-dimensions)_;
+Go to: _[array-dimensions](#user-content-array-dimensions), [type](#user-content-type)_;


 <a name="array-dimensions"></a>
@ -1127,7 +1128,7 @@ A literal is either an atomic one or an affine group literal.
 literal = atomic-literal / affine-group-literal
 ```

-Go to: _[atomic-literal](#user-content-atomic-literal), [affine-group-literal](#user-content-affine-group-literal)_;
+Go to: _[affine-group-literal](#user-content-affine-group-literal), [atomic-literal](#user-content-atomic-literal)_;


 The following rule is not directly referenced in the rules for expressions
@ -1140,7 +1141,7 @@ a group literal is either a product group literal or an affine group literal.
 group-literal = product-group-literal / affine-group-literal
 ```

-Go to: _[affine-group-literal](#user-content-affine-group-literal), [product-group-literal](#user-content-product-group-literal)_;
+Go to: _[product-group-literal](#user-content-product-group-literal), [affine-group-literal](#user-content-affine-group-literal)_;


 As often done in grammatical language syntax specifications,
@ -1169,7 +1170,7 @@ primary-expression = identifier
                   / circuit-expression
 ```

-Go to: _[expression](#user-content-expression), [array-expression](#user-content-array-expression), [literal](#user-content-literal), [identifier](#user-content-identifier), [circuit-expression](#user-content-circuit-expression), [tuple-expression](#user-content-tuple-expression)_;
+Go to: _[array-expression](#user-content-array-expression), [expression](#user-content-expression), [circuit-expression](#user-content-circuit-expression), [identifier](#user-content-identifier), [tuple-expression](#user-content-tuple-expression), [literal](#user-content-literal)_;


 Tuple expressions construct tuples.
@ -1230,7 +1231,7 @@ Go to: _[expression](#user-content-expression), [array-dimensions](#user-content
 array-construction = array-inline-construction / array-repeat-construction
 ```

-Go to: _[array-inline-construction](#user-content-array-inline-construction), [array-repeat-construction](#user-content-array-repeat-construction)_;
+Go to: _[array-repeat-construction](#user-content-array-repeat-construction), [array-inline-construction](#user-content-array-inline-construction)_;


 <a name="array-expression"></a>
@ -1317,7 +1318,7 @@ postfix-expression = primary-expression
                   / postfix-expression "[" [expression] ".." [expression] "]"
 ```

-Go to: _[natural](#user-content-natural), [identifier](#user-content-identifier), [circuit-type](#user-content-circuit-type), [primary-expression](#user-content-primary-expression), [function-arguments](#user-content-function-arguments), [postfix-expression](#user-content-postfix-expression), [expression](#user-content-expression)_;
+Go to: _[identifier](#user-content-identifier), [circuit-type](#user-content-circuit-type), [function-arguments](#user-content-function-arguments), [natural](#user-content-natural), [primary-expression](#user-content-primary-expression), [expression](#user-content-expression), [postfix-expression](#user-content-postfix-expression)_;


 Unary operators have the highest operator precedence.
@ -1331,7 +1332,7 @@ unary-expression = postfix-expression
                 / "-" unary-expression
 ```

-Go to: _[postfix-expression](#user-content-postfix-expression), [unary-expression](#user-content-unary-expression)_;
+Go to: _[unary-expression](#user-content-unary-expression), [postfix-expression](#user-content-postfix-expression)_;


 Next in the operator precedence is exponentiation,
@ -1357,7 +1358,7 @@ multiplicative-expression = exponential-expression
                          / multiplicative-expression "/" exponential-expression
 ```

-Go to: _[exponential-expression](#user-content-exponential-expression), [multiplicative-expression](#user-content-multiplicative-expression)_;
+Go to: _[multiplicative-expression](#user-content-multiplicative-expression), [exponential-expression](#user-content-exponential-expression)_;


 Then there are addition and subtraction, both left-assocative.
@ -1408,7 +1409,7 @@ conjunctive-expression = equality-expression
                       / conjunctive-expression "&&" equality-expression
 ```

-Go to: _[equality-expression](#user-content-equality-expression), [conjunctive-expression](#user-content-conjunctive-expression)_;
+Go to: _[conjunctive-expression](#user-content-conjunctive-expression), [equality-expression](#user-content-equality-expression)_;


 Next come disjunctive expressions, left-associative.
@ -1419,7 +1420,7 @@ disjunctive-expression = conjunctive-expression
                       / disjunctive-expression "||" conjunctive-expression
 ```

-Go to: _[conjunctive-expression](#user-content-conjunctive-expression), [disjunctive-expression](#user-content-disjunctive-expression)_;
+Go to: _[disjunctive-expression](#user-content-disjunctive-expression), [conjunctive-expression](#user-content-conjunctive-expression)_;


 Finally we have conditional expressions.
@ -1432,7 +1433,7 @@ conditional-expression = disjunctive-expression
                         ":" conditional-expression
 ```

-Go to: _[expression](#user-content-expression), [disjunctive-expression](#user-content-disjunctive-expression), [conditional-expression](#user-content-conditional-expression)_;
+Go to: _[disjunctive-expression](#user-content-disjunctive-expression), [expression](#user-content-expression), [conditional-expression](#user-content-conditional-expression)_;


 Those above are all the expressions.
@ -1465,7 +1466,7 @@ statement = expression-statement
          / block
 ```

-Go to: _[constant-declaration](#user-content-constant-declaration), [block](#user-content-block), [variable-declaration](#user-content-variable-declaration), [conditional-statement](#user-content-conditional-statement), [return-statement](#user-content-return-statement), [assignment-statement](#user-content-assignment-statement), [expression-statement](#user-content-expression-statement), [loop-statement](#user-content-loop-statement), [console-statement](#user-content-console-statement)_;
+Go to: _[loop-statement](#user-content-loop-statement), [assignment-statement](#user-content-assignment-statement), [variable-declaration](#user-content-variable-declaration), [expression-statement](#user-content-expression-statement), [conditional-statement](#user-content-conditional-statement), [block](#user-content-block), [console-statement](#user-content-console-statement), [return-statement](#user-content-return-statement), [constant-declaration](#user-content-constant-declaration)_;


 <a name="block"></a>
@ -1508,7 +1509,7 @@ variable-declaration = %s"let" identifier-or-identifiers [ ":" type ]
                       "=" expression ";"
 ```

-Go to: _[type](#user-content-type), [expression](#user-content-expression), [identifier-or-identifiers](#user-content-identifier-or-identifiers)_;
+Go to: _[type](#user-content-type), [identifier-or-identifiers](#user-content-identifier-or-identifiers), [expression](#user-content-expression)_;


 <a name="constant-declaration"></a>
@ -1517,7 +1518,7 @@ constant-declaration = %s"const" identifier-or-identifiers [ ":" type ]
                       "=" expression ";"
 ```

-Go to: _[identifier-or-identifiers](#user-content-identifier-or-identifiers), [type](#user-content-type), [expression](#user-content-expression)_;
+Go to: _[type](#user-content-type), [expression](#user-content-expression), [identifier-or-identifiers](#user-content-identifier-or-identifiers)_;


 <a name="identifier-or-identifiers"></a>
@ -1540,7 +1541,7 @@ Note that blocks are required in all branches, not merely statements.
 branch = %s"if" expression block
 ```

-Go to: _[block](#user-content-block), [expression](#user-content-expression)_;
+Go to: _[expression](#user-content-expression), [block](#user-content-block)_;


 <a name="conditional-statement"></a>
@ -1550,7 +1551,7 @@ conditional-statement = branch
                      / branch %s"else" conditional-statement
 ```

-Go to: _[branch](#user-content-branch), [conditional-statement](#user-content-conditional-statement), [block](#user-content-block)_;
+Go to: _[branch](#user-content-branch), [block](#user-content-block), [conditional-statement](#user-content-conditional-statement)_;


 A loop statement implicitly defines a loop variable
@ -1606,7 +1607,7 @@ console-call = assert-call
             / print-call
 ```

-Go to: _[assert-call](#user-content-assert-call), [print-call](#user-content-print-call)_;
+Go to: _[print-call](#user-content-print-call), [assert-call](#user-content-assert-call)_;


 <a name="assert-call"></a>
@ -1665,7 +1666,7 @@ function-declaration = *annotation %s"function" identifier
                       block
 ```

-Go to: _[block](#user-content-block), [identifier](#user-content-identifier), [function-parameters](#user-content-function-parameters), [type](#user-content-type)_;
+Go to: _[identifier](#user-content-identifier), [function-parameters](#user-content-function-parameters), [type](#user-content-type), [block](#user-content-block)_;


 <a name="function-parameters"></a>
@ -1675,7 +1676,7 @@ function-parameters = self-parameter
                    / function-inputs
 ```

-Go to: _[function-inputs](#user-content-function-inputs), [self-parameter](#user-content-self-parameter)_;
+Go to: _[self-parameter](#user-content-self-parameter), [function-inputs](#user-content-function-inputs)_;


 <a name="self-parameter"></a>
@ -1744,7 +1745,7 @@ circuit-declaration = %s"circuit" identifier
                      *member-function-declaration "}"
 ```

-Go to: _[identifier](#user-content-identifier), [member-variable-declarations](#user-content-member-variable-declarations)_;
+Go to: _[member-variable-declarations](#user-content-member-variable-declarations), [identifier](#user-content-identifier)_;


 An import declaration consists of the `import` keyword
@ -1766,7 +1767,7 @@ by using an explicit package name before the package path.
 import-declaration = %s"import" package-name "." package-path ";"
 ```

-Go to: _[package-path](#user-content-package-path), [package-name](#user-content-package-name)_;
+Go to: _[package-name](#user-content-package-name), [package-path](#user-content-package-path)_;


 <a name="package-path"></a>
@ -1777,7 +1778,7 @@ package-path = "*"
             / "(" package-path *( "," package-path ) [","] ")"
 ```

-Go to: _[package-name](#user-content-package-name), [identifier](#user-content-identifier), [package-path](#user-content-package-path)_;
+Go to: _[identifier](#user-content-identifier), [package-path](#user-content-package-path), [package-name](#user-content-package-name)_;


 Finally, we define a file as a sequence of zero or more declarations.
@ -1792,7 +1793,7 @@ declaration = import-declaration
            / constant-declaration
 ```

-Go to: _[function-declaration](#user-content-function-declaration), [circuit-declaration](#user-content-circuit-declaration), [constant-declaration](#user-content-constant-declaration), [import-declaration](#user-content-import-declaration)_;
+Go to: _[function-declaration](#user-content-function-declaration), [constant-declaration](#user-content-constant-declaration), [import-declaration](#user-content-import-declaration), [circuit-declaration](#user-content-circuit-declaration)_;


 <a name="file"></a>
--- a/grammar/abnf-grammar.txt
+++ b/grammar/abnf-grammar.txt
@ -421,10 +421,7 @@ keyword = %s"address"
        / %s"u64"
        / %s"u128"

-; The following rules define (ASCII)
-; digits and (uppercase and lowercase) letters.
-
-digit = %x30-39   ; 0-9
+; The following rules define (ASCII) letters.

 uppercase-letter = %x41-5A   ; A-Z

@ -432,30 +429,34 @@ lowercase-letter = %x61-7A   ; a-z

 letter = uppercase-letter / lowercase-letter

-; The following rules defines (ASCII) octal and hexadecimal digits.
+; The following rules defines (ASCII) decimal, octal, and hexadecimal digits.
 ; Note that the latter are case-insensitive.

+decimal-digit = %x30-39   ; 0-9
+
 octal-digit = %x30-37   ; 0-7

-hexadecimal-digit = digit / "a" / "b" / "c" / "d" / "e" / "f"
+hexadecimal-digit = decimal-digit / "a" / "b" / "c" / "d" / "e" / "f"

-; An identifier is a non-empty sequence of letters, digits, and underscores,
+; An identifier is a non-empty sequence of
+; letters, (decimal) digits, and underscores,
 ; starting with a letter.
 ; It must not be a keyword: this is an extra-grammatical requirement.
 ; It must also not be or start with `aleo1`,
 ; because that is used for address literals:
 ; this is another extra-grammatical requirement.

-identifier = letter *( letter / digit / "_" )
+identifier = letter *( letter / decimal-digit / "_" )
             ; but not a keyword or a boolean literal or aleo1...

 ; A package name consists of one or more segments separated by single dashes,
-; where each segment is a non-empty sequence of lowercase letters and digits.
+; where each segment is a non-empty sequence of
+; lowercase letters and (decimal) digits.
 ; Similarly to an identifier, a package name must not be a keyword
 ; and must not be or start with `aleo1`.

-package-name = lowercase-letter *( lowercase-letter / digit )
-               *( "-" 1*( lowercase-letter / digit ) )
+package-name = lowercase-letter *( lowercase-letter / decimal-digit )
+               *( "-" 1*( lowercase-letter / decimal-digit ) )
               ; but not a keyword or a boolean literal or aleo1...

 ; Note that, grammatically, identifiers are also package names.
@ -465,10 +466,10 @@ package-name = lowercase-letter *( lowercase-letter / digit )

 annotation-name = "@" identifier

-; A natural (number) is a sequence of one or more digits.
+; A natural (number) is a sequence of one or more decimal digits.
 ; We allow leading zeros, e.g. `007`.

-natural = 1*digit
+natural = 1*decimal-digit

 ; An integer (number) is either a natural or its negation.
 ; We allow leading zeros also in negative numbers, e.g. `-007`.
@ -504,10 +505,10 @@ product-group-literal = integer %s"group"
 boolean-literal = %s"true" / %s"false"

 ; An address literal starts with `aleo1`
-; and continues with exactly 58 lowercase letters and digits.
+; and continues with exactly 58 lowercase letters and (decimal) digits.
 ; Thus an address always consists of 63 characters.

-address-literal = %s"aleo1" 58( lowercase-letter / digit )
+address-literal = %s"aleo1" 58( lowercase-letter / decimal-digit )

 ; A character literal consists of an element surrounded by single quotes.
 ; The element is any character other than single quote or backslash,
--- a/imports/Cargo.toml
+++ b/imports/Cargo.toml
@ -37,8 +37,5 @@ version = "1.5.3"
 version = "1.7.0"
 features = [ "serde-1" ]

-[dependencies.thiserror]
-version = "1.0"
-
 [dependencies.tracing]
 version = "0.1"
--- a/leo/api.rs
+++ b/leo/api.rs
@ -18,8 +18,7 @@ use leo_errors::{CliError, LeoError, Result};

 use reqwest::{
    blocking::{multipart::Form, Client, Response},
-    Method,
-    StatusCode,
+    Method, StatusCode,
 };
 use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, path::PathBuf};
--- a/leo/commands/build.rs
+++ b/leo/commands/build.rs
@ -18,8 +18,7 @@ use crate::{commands::Command, context::Context};
 use leo_compiler::{
    compiler::{thread_leaked_context, Compiler},
    group::targets::edwards_bls12::EdwardsGroupType,
-    AstSnapshotOptions,
-    CompilerOptions,
+    AstSnapshotOptions, CompilerOptions,
 };
 use leo_errors::{CliError, Result};
 use leo_package::{
--- a/leo/commands/package/clone.rs
+++ b/leo/commands/package/clone.rs
@ -20,8 +20,7 @@ use leo_errors::{CliError, Result};
 use std::{
    borrow::Cow,
    fs::{
-        File,
-        {self},
+        File, {self},
    },
    io::{Read, Write},
    path::Path,
--- a/leo/config.rs
+++ b/leo/config.rs
@ -18,9 +18,7 @@ use leo_errors::{CliError, Result};

 use std::{
    fs::{
-        create_dir_all,
-        File,
-        {self},
+        create_dir_all, File, {self},
    },
    io::prelude::*,
    path::{Path, PathBuf},
--- a/leo/main.rs
+++ b/leo/main.rs
@ -23,19 +23,7 @@ pub mod updater;

 use commands::{
    package::{Add, Clone, Login, Logout, Publish, Remove},
-    Build,
-    Clean,
-    Command,
-    Deploy,
-    Init,
-    Lint,
-    New,
-    Prove,
-    Run,
-    Setup,
-    Test,
-    Update,
-    Watch,
+    Build, Clean, Command, Deploy, Init, Lint, New, Prove, Run, Setup, Test, Update, Watch,
 };
 use leo_errors::Result;

@ -182,7 +170,6 @@ enum CommandOpts {
 }

 fn main() {
-    color_backtrace::install();
    handle_error(run_with_args(Opt::from_args()))
 }

@ -190,10 +177,13 @@ fn main() {
 fn run_with_args(opt: Opt) -> Result<()> {
    if !opt.quiet {
        // Init logger with optional debug flag.
-        logger::init_logger("leo", match opt.debug {
+        logger::init_logger(
+            "leo",
+            match opt.debug {
                false => 1,
                true => 2,
-        })?;
+            },
+        )?;
    }

    // Get custom root folder and create context for it.
@ -253,7 +243,7 @@ fn handle_error<T>(res: Result<T>) -> T {
 #[cfg(test)]
 mod cli_tests {
    use crate::{run_with_args, Opt};
-    use leo_errors::Result;
+    use leo_errors::{CliError, Result};

    use std::path::PathBuf;
    use structopt::StructOpt;
@ -262,7 +252,7 @@ mod cli_tests {
    // Runs Command from cmd-like argument "leo run --arg1 --arg2".
    fn run_cmd(args: &str, path: &Option<PathBuf>) -> Result<()> {
        let args = args.split(' ').collect::<Vec<&str>>();
-        let mut opts = Opt::from_iter_safe(args).unwrap();
+        let mut opts = Opt::from_iter_safe(args).map_err(CliError::opt_args_error)?;

        if path.is_some() {
            opts.path = path.clone();
@ -287,9 +277,6 @@ mod cli_tests {

        assert!(run_cmd("leo build", &path).is_ok());
        assert!(run_cmd("leo -q build", &path).is_ok());
-
-        assert!(run_cmd("leo --path ../../examples/no-directory-there build", &None).is_err());
-        assert!(run_cmd("leo -v build", &None).is_err());
    }

    #[test]
--- a/leo/tests/mod.rs
+++ b/leo/tests/mod.rs
@ -20,14 +20,7 @@ use std::path::PathBuf;
 use crate::{
    commands::{
        package::{Login, Logout},
-        Build,
-        Command,
-        Prove,
-        Run,
-        Setup,
-        Test,
-        Update,
-        UpdateAutomatic,
+        Build, Command, Prove, Run, Setup, Test, Update, UpdateAutomatic,
    },
    context::{create_context, Context},
 };
@ -150,7 +143,8 @@ pub fn test_pedersen_hash() -> Result<()> {

 #[test]
 pub fn test_logout() -> Result<()> {
-    (Logout {}).apply(context()?, ())?;
+    let logout = (Logout {}).apply(context()?, ());
+    assert!(logout.is_err());
    Ok(())
 }

--- a/package/src/inputs/input.rs
+++ b/package/src/inputs/input.rs
@ -24,8 +24,7 @@ use serde::Deserialize;
 use std::{
    borrow::Cow,
    fs::{
-        File,
-        {self},
+        File, {self},
    },
    io::Write,
    path::Path,
--- a/package/src/inputs/state.rs
+++ b/package/src/inputs/state.rs
@ -23,8 +23,7 @@ use serde::Deserialize;
 use std::{
    borrow::Cow,
    fs::{
-        File,
-        {self},
+        File, {self},
    },
    io::Write,
    path::Path,
--- a/package/src/outputs/checksum.rs
+++ b/package/src/outputs/checksum.rs
@ -23,8 +23,7 @@ use serde::Deserialize;
 use std::{
    borrow::Cow,
    fs::{
-        File,
-        {self},
+        File, {self},
    },
    io::Write,
    path::Path,
--- a/package/src/outputs/circuit.rs
+++ b/package/src/outputs/circuit.rs
@ -23,8 +23,7 @@ use serde::Deserialize;
 use std::{
    borrow::Cow,
    fs::{
-        File,
-        {self},
+        File, {self},
    },
    io::Write,
    path::Path,
--- a/package/src/outputs/proof.rs
+++ b/package/src/outputs/proof.rs
@ -23,8 +23,7 @@ use serde::Deserialize;
 use std::{
    borrow::Cow,
    fs::{
-        File,
-        {self},
+        File, {self},
    },
    io::Write,
    path::Path,
--- a/package/src/outputs/proving_key.rs
+++ b/package/src/outputs/proving_key.rs
@ -23,8 +23,7 @@ use serde::Deserialize;
 use std::{
    borrow::Cow,
    fs::{
-        File,
-        {self},
+        File, {self},
    },
    io::Write,
    path::Path,
--- a/package/src/outputs/verification_key.rs
+++ b/package/src/outputs/verification_key.rs
@ -23,8 +23,7 @@ use serde::Deserialize;
 use std::{
    borrow::Cow,
    fs::{
-        File,
-        {self},
+        File, {self},
    },
    io::Write,
    path::Path,
--- a/package/src/root/zip.rs
+++ b/package/src/root/zip.rs
@ -20,12 +20,8 @@ use crate::{
    imports::IMPORTS_DIRECTORY_NAME,
    inputs::{INPUTS_DIRECTORY_NAME, INPUT_FILE_EXTENSION, STATE_FILE_EXTENSION},
    outputs::{
-        CHECKSUM_FILE_EXTENSION,
-        CIRCUIT_FILE_EXTENSION,
-        OUTPUTS_DIRECTORY_NAME,
-        PROOF_FILE_EXTENSION,
-        PROVING_KEY_FILE_EXTENSION,
-        VERIFICATION_KEY_FILE_EXTENSION,
+        CHECKSUM_FILE_EXTENSION, CIRCUIT_FILE_EXTENSION, OUTPUTS_DIRECTORY_NAME, PROOF_FILE_EXTENSION,
+        PROVING_KEY_FILE_EXTENSION, VERIFICATION_KEY_FILE_EXTENSION,
    },
    root::{MANIFEST_FILENAME, README_FILENAME},
    source::{SOURCE_DIRECTORY_NAME, SOURCE_FILE_EXTENSION},
@ -36,8 +32,7 @@ use serde::Deserialize;
 use std::{
    borrow::Cow,
    fs::{
-        File,
-        {self},
+        File, {self},
    },
    io::{Read, Write},
    path::Path,
--- a/package/tests/mod.rs
+++ b/package/tests/mod.rs
@ -22,8 +22,7 @@ pub mod manifest;
 use lazy_static::lazy_static;
 use std::{
    cell::RefCell,
-    env,
-    fs,
+    env, fs,
    path::PathBuf,
    sync::atomic::{AtomicUsize, Ordering},
 };
--- a/parser/src/parser/expression.rs
+++ b/parser/src/parser/expression.rs
@ -558,11 +558,11 @@ impl ParserContext {
    pub fn parse_tuple_expression(&mut self, span: &Span) -> Result<Expression> {
        if let Some((left, right, span)) = self.eat_group_partial().transpose()? {
            return Ok(Expression::Value(ValueExpression::Group(Box::new(GroupValue::Tuple(
-                Box::new(GroupTuple {
+                GroupTuple {
                    span,
                    x: left,
                    y: right,
-                }),
+                },
            )))));
        }
        let mut args = Vec::new();
--- a/parser/src/parser/file.rs
+++ b/parser/src/parser/file.rs
@ -193,17 +193,17 @@ impl ParserContext {
                })
            } else if self.eat(Token::As).is_some() {
                let alias = self.expect_ident()?;
-                Ok(PackageAccess::Symbol(Box::new(ImportSymbol {
+                Ok(PackageAccess::Symbol(ImportSymbol {
                    span: &name.span + &alias.span,
                    symbol: name,
                    alias: Some(alias),
-                })))
+                }))
            } else {
-                Ok(PackageAccess::Symbol(Box::new(ImportSymbol {
+                Ok(PackageAccess::Symbol(ImportSymbol {
                    span: name.span.clone(),
                    symbol: name,
                    alias: None,
-                })))
+                }))
            }
        }
    }
@ -371,7 +371,7 @@ impl ParserContext {
        let peeked = self.peek()?.clone();
        if peeked.token == Token::Function || peeked.token == Token::At {
            let function = self.parse_function_declaration()?;
-            Ok(CircuitMember::CircuitFunction(Box::new(function.1)))
+            Ok(CircuitMember::CircuitFunction(function.1))
        } else {
            return Err(ParserError::unexpected(
                &peeked.token,
@ -396,10 +396,13 @@ impl ParserContext {
        self.expect(Token::LeftCurly)?;
        let members = self.parse_circuit_declaration()?;

-        Ok((name.clone(), Circuit {
+        Ok((
+            name.clone(),
+            Circuit {
                circuit_name: name,
                members,
-        }))
+            },
+        ))
    }

    ///
@ -421,9 +424,7 @@ impl ParserContext {
                // Handle `mut self`.
                name.span = &mutable.span + &name.span;
                name.name = "mut self".to_string().into();
-                return Ok(FunctionInput::MutSelfKeyword(Box::new(MutSelfKeyword {
-                    identifier: name,
-                })));
+                return Ok(FunctionInput::MutSelfKeyword(MutSelfKeyword { identifier: name }));
            } else if let Some(const_) = &const_ {
                // Handle `const self`.
                name.span = &const_.span + &name.span;
@ -440,13 +441,13 @@ impl ParserContext {

        self.expect(Token::Colon)?;
        let type_ = self.parse_type()?.0;
-        Ok(FunctionInput::Variable(Box::new(FunctionInputVariable {
+        Ok(FunctionInput::Variable(FunctionInputVariable {
            const_: const_.is_some(),
            mutable: const_.is_none(),
            type_,
            span: name.span.clone(),
            identifier: name,
-        })))
+        }))
    }

    ///
@ -476,14 +477,17 @@ impl ParserContext {
            None
        };
        let block = self.parse_block()?;
-        Ok((name.clone(), Function {
+        Ok((
+            name.clone(),
+            Function {
                annotations,
                identifier: name,
                input: inputs,
                output,
                span: start + block.span.clone(),
                block,
-        }))
+            },
+        ))
    }

    ///
--- a/parser/src/tokenizer/mod.rs
+++ b/parser/src/tokenizer/mod.rs
@ -195,7 +195,7 @@ mod tests {
        *=
        +
        +=
-
+        ,
        -
        -=
        ->
@ -231,6 +231,7 @@ mod tests {
        for SpannedToken { token, .. } in tokens.iter() {
            output += &format!("{} ", token.to_string());
        }
+
        // & &= | |= ^ ^= ~ << <<= >> >>= >>> >>>= % %= ||= &&=
        assert_eq!(
            output,
--- a/state/Cargo.toml
+++ b/state/Cargo.toml
@ -30,18 +30,18 @@ path = "../input"
 version = "1.5.3"

 [dependencies.snarkvm-algorithms]
-version = "0.7.4"
+version = "0.7.6"

 [dependencies.snarkvm-curves]
-version = "0.7.5"
+version = "0.7.7"
 default-features = false

 [dependencies.snarkvm-dpc]
-version = "0.7.5"
+version = "0.7.7"
 features = [ "testnet1" ]

 [dependencies.snarkvm-utilities]
-version = "0.7.4"
+version = "0.7.6"

 [dependencies.indexmap]
 version = "1.7.0"
@ -53,8 +53,5 @@ version = "0.8"
 [dependencies.rand_xorshift]
 version = "0.3"

-[dependencies.thiserror]
-version = "1.0"
-
 [dev-dependencies.rand_core]
 version = "0.6.3"
--- a/state/src/local_data_commitment/local_data_commitment.rs
+++ b/state/src/local_data_commitment/local_data_commitment.rs
@ -56,8 +56,7 @@ pub fn verify_local_data_commitment(dpc: &SystemParameters<Components>, ast_inpu
    // Select local data commitment input bytes.
    let is_death = leaf_index < (Components::NUM_INPUT_RECORDS as u32);
    let input_bytes = if is_death {
-        to_bytes_le![record_serial_number, record_commitment, memo, network_id]
-            .map_err(StateError::state_io_error)?
+        to_bytes_le![record_serial_number, record_commitment, memo, network_id].map_err(StateError::state_io_error)?
    } else {
        to_bytes_le![record_commitment, memo, network_id].map_err(StateError::state_io_error)?
    };
--- a/state/src/utilities/input_value.rs
+++ b/state/src/utilities/input_value.rs
@ -53,9 +53,7 @@ pub fn input_to_bytes(input: InputValue) -> Result<Vec<u8>> {

    for input in input_array {
        let integer_string = input_to_integer_string(input)?;
-        let byte = integer_string
-            .parse::<u8>()
-            .map_err(StateError::parse_int_error)?;
+        let byte = integer_string.parse::<u8>().map_err(StateError::parse_int_error)?;

        result_vec.push(byte);
    }
--- a/synthesizer/Cargo.toml
+++ b/synthesizer/Cargo.toml
@ -18,7 +18,7 @@ license = "GPL-3.0"
 edition = "2018"

 [dependencies.snarkvm-curves]
-version = "0.7.5"
+version = "0.7.7"
 default-features = false

 [dependencies.leo-errors]
@ -30,14 +30,14 @@ version = "0.6.5"
 default-features = false

 [dependencies.snarkvm-fields]
-version = "0.7.5"
+version = "0.7.7"
 default-features = false

 [dependencies.snarkvm-gadgets]
-version = "0.7.5"
+version = "0.7.7"

 [dependencies.snarkvm-r1cs]
-version = "0.7.5"
+version = "0.7.7"
 default-features = false

 [dependencies.num-bigint]
--- a/test-framework/src/runner.rs
+++ b/test-framework/src/runner.rs
@ -174,11 +174,14 @@ pub fn run_tests<T: Runner>(runner: &T, expectation_category: &str) {

        if errors.is_empty() {
            if expectations.is_none() {
-                outputs.push((expectation_path, TestExpectation {
+                outputs.push((
+                    expectation_path,
+                    TestExpectation {
                        namespace: config.namespace,
                        expectation: config.expectation,
                        outputs: new_outputs,
-                }));
+                    },
+                ));
            }
            pass_categories += 1;
        } else {